home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / system16.c < prev    next >
C/C++ Source or Header  |  2000-04-23  |  80KB  |  3,063 lines
  1. /***************************************************************************
  2.  
  3. Sega System 16 Video Hardware
  4.  
  5. Each scrolling layer (foreground, background) is an arrangement
  6. of 4 pages selected from 16 available pages, laid out as follows:
  7.  
  8.     Page0  Page1
  9.     Page2  Page3
  10.  
  11. Each page is an arrangement of 8x8 tiles, 64 tiles wide, and 32 tiles high.
  12.  
  13. ***************************************************************************/
  14. void dump_tilemap(void);
  15.  
  16. #include "driver.h"
  17.  
  18. //#define SYS16_DEBUG
  19. //#define SPACEHARRIER_OFFSETS
  20.  
  21. // an attempt at fudging correct gamma for sys16 games, but I'm not sure that it's
  22. // really worth using.
  23. //#define GAMMA_ADJUST
  24. #define TRANSPARENT_SHADOWS
  25. #define MAXCOLOURS 8192
  26.  
  27. #ifdef TRANSPARENT_SHADOWS
  28. #define ShadowColorsShift 8
  29. UINT16 shade_table[MAXCOLOURS];
  30. int sys16_sh_shadowpal;
  31. #endif
  32.  
  33. int sys16_MaxShadowColors;
  34. static int sys16_MaxShadowColors_Shift;
  35.  
  36. #define NUM_SPRITES 128
  37.  
  38. extern UINT8 *sys16_textram;
  39. extern UINT8 *sys16_spriteram;
  40. extern UINT8 *sys16_tileram; /* contains tilemaps for 16 pages */
  41.  
  42. static struct sprite_list *sprite_list;
  43.  
  44. /* video driver constants (potentially different for each game) */
  45. int sys16_spritesystem;
  46. int sys16_sprxoffset;
  47. int sys16_bgxoffset;
  48. int sys16_fgxoffset;
  49. int *sys16_obj_bank;
  50. int sys16_textmode;
  51. int sys16_textlayer_lo_min;
  52. int sys16_textlayer_lo_max;
  53. int sys16_textlayer_hi_min;
  54. int sys16_textlayer_hi_max;
  55. int sys16_dactype;
  56. int sys16_bg1_trans; // alien syn + sys18
  57. int sys16_bg_priority_mode;
  58. int sys16_fg_priority_mode;
  59. int sys16_bg_priority_value;
  60. int sys16_fg_priority_value;
  61. int sys16_18_mode;
  62. int sys16_spritelist_end;
  63. int sys16_tilebank_switch;
  64. int sys16_rowscroll_scroll;
  65. int sys16_quartet_title_kludge;
  66. extern void (* sys16_update_proc)( void );
  67.  
  68. /* video registers */
  69. int sys16_tile_bank1;
  70. int sys16_tile_bank0;
  71. int sys16_refreshenable;
  72. int sys16_clear_screen;
  73. int sys16_bg_scrollx, sys16_bg_scrolly;
  74. int sys16_bg_page[4];
  75. int sys16_fg_scrollx, sys16_fg_scrolly;
  76. int sys16_fg_page[4];
  77.  
  78. int sys16_bg2_scrollx, sys16_bg2_scrolly;
  79. int sys16_bg2_page[4];
  80. int sys16_fg2_scrollx, sys16_fg2_scrolly;
  81. int sys16_fg2_page[4];
  82.  
  83. int sys18_bg2_active;
  84. int sys18_fg2_active;
  85. unsigned char *sys18_splittab_bg_x;
  86. unsigned char *sys18_splittab_bg_y;
  87. unsigned char *sys18_splittab_fg_x;
  88. unsigned char *sys18_splittab_fg_y;
  89.  
  90. static int sys16_freezepalette;
  91. static int sys16_palettedirty[MAXCOLOURS];
  92.  
  93. #ifdef SPACEHARRIER_OFFSETS
  94. unsigned char *spaceharrier_patternoffsets;
  95. #endif
  96. unsigned char *gr_ver;
  97. unsigned char *gr_hor;
  98. unsigned char *gr_pal;
  99. unsigned char *gr_flip;
  100. int gr_palette;
  101. int gr_palette_default;
  102. unsigned char gr_colorflip[2][4];
  103. unsigned char *gr_second_road;
  104.  
  105. static struct tilemap *background, *foreground, *text_layer;
  106. static struct tilemap *background2, *foreground2;
  107. static int old_bg_page[4],old_fg_page[4], old_tile_bank1, old_tile_bank0;
  108. static int old_bg2_page[4],old_fg2_page[4];
  109.  
  110. static void draw_quartet_title_screen( struct osd_bitmap *bitmap,int playfield );
  111.  
  112. /***************************************************************************/
  113.  
  114. UINT32 sys16_bg_map( UINT32 col, UINT32 row, UINT32 num_cols, UINT32 num_rows ){
  115.     int page = 0;
  116.     if( row<32 ){ /* top */
  117.         if( col<64 ) page = 0; else page = 1;
  118.     }
  119.     else { /* bottom */
  120.         if( col<64 ) page = 2; else page = 3;
  121.     }
  122.     row = row%32;
  123.     col = col%64;
  124.     return page*64*32+row*64+col;
  125. }
  126.  
  127. UINT32 sys16_text_map( UINT32 col, UINT32 row, UINT32 num_cols, UINT32 num_rows ){
  128.     return row*64+col+(64-40);
  129. }
  130.  
  131. /***************************************************************************/
  132.  
  133. WRITE_HANDLER( sys16_paletteram_w ){
  134.     UINT16 oldword = READ_WORD (&paletteram[offset]);
  135.     UINT16 newword = COMBINE_WORD (oldword, data);
  136.     if( oldword!=newword ){
  137.         /* we can do this, because we initialize palette RAM to all black in vh_start */
  138.         /*       byte 0    byte 1 */
  139.         /*    GBGR BBBB GGGG RRRR */
  140.         /*    5444 3210 3210 3210 */
  141.         UINT8 r = (newword & 0x00f)<<1;
  142.         UINT8 g = (newword & 0x0f0)>>2;
  143.         UINT8 b = (newword & 0xf00)>>7;
  144.         if( sys16_dactype == 0 ){
  145.             /* dac_type == 0 (from GCS file) */
  146.             if (newword&0x1000) r|=1;
  147.             if (newword&0x2000) g|=2;
  148.             if (newword&0x8000) g|=1;
  149.             if (newword&0x4000) b|=1;
  150.         }
  151.         else if( sys16_dactype == 1 ){
  152.             /* dac_type == 1 (from GCS file) Shinobi Only*/
  153.             if (newword&0x1000) r|=1;
  154.             if (newword&0x4000) g|=2;
  155.             if (newword&0x8000) g|=1;
  156.             if (newword&0x2000) b|=1;
  157.         }
  158.  
  159. #ifndef TRANSPARENT_SHADOWS
  160.         if( !sys16_freezepalette ){
  161.             palette_change_color( offset/2,
  162.                 (r << 3) | (r >> 2), /* 5 bits red */
  163.                 (g << 2) | (g >> 4), /* 6 bits green */
  164.                 (b << 3) | (b >> 2) /* 5 bits blue */
  165.             );
  166.         }
  167.         else{
  168.             r=(r << 3) | (r >> 2); /* 5 bits red */
  169.             g=(g << 2) | (g >> 4); /* 6 bits green */
  170.             b=(b << 3) | (b >> 2); /* 5 bits blue */
  171.             sys16_palettedirty[offset/2]=0xff000000+(r<<16)+(g<<8)+b;
  172.         }
  173. #else
  174.         if (Machine->scrbitmap->depth == 8){ /* 8 bit shadows */
  175.             if(!sys16_freezepalette){
  176.                 palette_change_color( offset/2,
  177.                     (r << 3) | (r >> 3), /* 5 bits red */
  178.                     (g << 2) | (g >> 4), /* 6 bits green */
  179.                     (b << 3) | (b >> 3) /* 5 bits blue */
  180.                 );
  181.             }
  182.             else {
  183.                 r=(r << 3) | (r >> 3); /* 5 bits red */
  184.                 g=(g << 2) | (g >> 4); /* 6 bits green */
  185.                 b=(b << 3) | (b >> 3); /* 5 bits blue */
  186.                 sys16_palettedirty[offset/2]=0xff000000+(r<<16)+(g<<8)+b;
  187.             }
  188.         }
  189.         else {
  190.             if(!sys16_freezepalette){
  191.                 r=(r << 3) | (r >> 2); /* 5 bits red */
  192.                 g=(g << 2) | (g >> 4); /* 6 bits green */
  193.                 b=(b << 3) | (b >> 2); /* 5 bits blue */
  194.  
  195.                 palette_change_color( offset/2,r,g,b);
  196.  
  197.                 /* shadow color */
  198.  
  199.                 r= r * 160 / 256;
  200.                 g= g * 160 / 256;
  201.                 b= b * 160 / 256;
  202.  
  203.                 palette_change_color( offset/2+Machine->drv->total_colors/2,r,g,b);
  204.             }
  205.             else {
  206.                 r=(r << 3) | (r >> 3); /* 5 bits red */
  207.                 g=(g << 2) | (g >> 4); /* 6 bits green */
  208.                 b=(b << 3) | (b >> 3); /* 5 bits blue */
  209.                 sys16_palettedirty[offset/2]=0xff000000+(r<<16)+(g<<8)+b;
  210.  
  211.                 r= r * 160 / 256;
  212.                 g= g * 160 / 256;
  213.                 b= b * 160 / 256;
  214.                 sys16_palettedirty[offset/2+Machine->drv->total_colors/2]=0xff000000+(r<<16)+(g<<8)+b;
  215.             }
  216.         }
  217. #endif
  218.         WRITE_WORD (&paletteram[offset], newword);
  219.     }
  220. }
  221.  
  222. static void sys16_refresh_palette(void){
  223.     UINT8 r,g,b;
  224.     int i;
  225.     for( i=0;i<Machine->drv->total_colors;i++ ){
  226.         if( sys16_palettedirty[i] ){
  227.             r=(sys16_palettedirty[i]&0x00ff0000) >> 16;
  228.             g=(sys16_palettedirty[i]&0x0000ff00) >> 8;
  229.             b=(sys16_palettedirty[i]&0x000000ff);
  230.             palette_change_color(i,r,g,b);
  231.             sys16_palettedirty[i]=0;
  232.         }
  233.     }
  234. }
  235.  
  236. static void update_page( void ){
  237.     int all_dirty = 0;
  238.     int i,offset;
  239.     if( old_tile_bank1 != sys16_tile_bank1 ){
  240.         all_dirty = 1;
  241.         old_tile_bank1 = sys16_tile_bank1;
  242.     }
  243.     if( old_tile_bank0 != sys16_tile_bank0 ){
  244.         all_dirty = 1;
  245.         old_tile_bank0 = sys16_tile_bank0;
  246.         tilemap_mark_all_tiles_dirty( text_layer );
  247.     }
  248.     if( all_dirty ){
  249.         tilemap_mark_all_tiles_dirty( background );
  250.         tilemap_mark_all_tiles_dirty( foreground );
  251.         if( sys16_18_mode ){
  252.             tilemap_mark_all_tiles_dirty( background2 );
  253.             tilemap_mark_all_tiles_dirty( foreground2 );
  254.         }
  255.     }
  256.     else {
  257.         for(i=0;i<4;i++){
  258.             int page0 = 64*32*i;
  259.             if( old_bg_page[i]!=sys16_bg_page[i] ){
  260.                 old_bg_page[i] = sys16_bg_page[i];
  261.                 for( offset = page0; offset<page0+64*32; offset++ ){
  262.                     tilemap_mark_tile_dirty( background, offset );
  263.                 }
  264.             }
  265.             if( old_fg_page[i]!=sys16_fg_page[i] ){
  266.                 old_fg_page[i] = sys16_fg_page[i];
  267.                 for( offset = page0; offset<page0+64*32; offset++ ){
  268.                     tilemap_mark_tile_dirty( foreground, offset );
  269.                 }
  270.             }
  271.             if( sys16_18_mode ){
  272.                 if( old_bg2_page[i]!=sys16_bg2_page[i] ){
  273.                     old_bg2_page[i] = sys16_bg2_page[i];
  274.                     for( offset = page0; offset<page0+64*32; offset++ ){
  275.                         tilemap_mark_tile_dirty( background2, offset );
  276.                     }
  277.                 }
  278.                 if( old_fg2_page[i]!=sys16_fg2_page[i] ){
  279.                     old_fg2_page[i] = sys16_fg2_page[i];
  280.                     for( offset = page0; offset<page0+64*32; offset++ ){
  281.                         tilemap_mark_tile_dirty( foreground2, offset );
  282.                     }
  283.                 }
  284.             }
  285.         }
  286.     }
  287. }
  288.  
  289. static void get_bg_tile_info( int offset ){
  290.     const UINT16 *source = 64*32*sys16_bg_page[offset/(64*32)] + (UINT16 *)sys16_tileram;
  291.     int data = source[offset%(64*32)];
  292.     int tile_number = (data&0xfff) + 0x1000*((data&sys16_tilebank_switch)?sys16_tile_bank1:sys16_tile_bank0);
  293.  
  294.     if(sys16_textmode==0){
  295.         SET_TILE_INFO( 0, tile_number, (data>>6)&0x7f );
  296.     }
  297.     else{
  298.         SET_TILE_INFO( 0, tile_number, (data>>5)&0x7f );
  299.     }
  300.  
  301.     switch(sys16_bg_priority_mode) {
  302.     case 1: // Alien Syndrome
  303.         tile_info.priority = (data&0x8000)?1:0;
  304.         break;
  305.     case 2: // Body Slam / wrestwar
  306.         tile_info.priority = ((data&0xff00) >= sys16_bg_priority_value)?1:0;
  307.         break;
  308.     case 3: // sys18 games
  309.         if( data&0x8000 ){
  310.             tile_info.priority = 2;
  311.         }
  312.         else {
  313.             tile_info.priority = ((data&0xff00) >= sys16_bg_priority_value)?1:0;
  314.         }
  315.         break;
  316.     }
  317. }
  318.  
  319. static void get_fg_tile_info( int offset ){
  320.     const UINT16 *source = 64*32*sys16_fg_page[offset/(64*32)] + (UINT16 *)sys16_tileram;
  321.     int data = source[offset%(64*32)];
  322.     int tile_number = (data&0xfff) + 0x1000*((data&sys16_tilebank_switch)?sys16_tile_bank1:sys16_tile_bank0);
  323.  
  324.     if(sys16_textmode==0){
  325.         SET_TILE_INFO( 0, tile_number, (data>>6)&0x7f );
  326.     }
  327.     else{
  328.         SET_TILE_INFO( 0, tile_number, (data>>5)&0x7f );
  329.     }
  330.     switch(sys16_fg_priority_mode){
  331.     case 1: // alien syndrome
  332.         tile_info.priority = (data&0x8000)?1:0;
  333.         break;
  334.  
  335.     case 3:
  336.         tile_info.priority = ((data&0xff00) >= sys16_fg_priority_value)?1:0;
  337.         break;
  338.  
  339.     default:
  340.         if( sys16_fg_priority_mode>=0 ){
  341.             tile_info.priority = (data&0x8000)?1:0;
  342.         }
  343.         break;
  344.     }
  345. }
  346.  
  347. static void get_bg2_tile_info( int offset ){
  348.     const UINT16 *source = 64*32*sys16_bg2_page[offset/(64*32)] + (UINT16 *)sys16_tileram;
  349.     int data = source[offset%(64*32)];
  350.     int tile_number = (data&0xfff) + 0x1000*((data&0x1000)?sys16_tile_bank1:sys16_tile_bank0);
  351.     if(sys16_textmode==0){
  352.         SET_TILE_INFO( 0, tile_number, (data>>6)&0x7f );
  353.     }
  354.     else{
  355.         SET_TILE_INFO( 0, tile_number, (data>>5)&0x7f );
  356.     }
  357.     tile_info.priority = 0;
  358. }
  359.  
  360. static void get_fg2_tile_info( int offset ){
  361.     const UINT16 *source = 64*32*sys16_fg2_page[offset/(64*32)] + (UINT16 *)sys16_tileram;
  362.     int data = source[offset%(64*32)];
  363.     int tile_number = (data&0xfff) + 0x1000*((data&0x1000)?sys16_tile_bank1:sys16_tile_bank0);
  364.     if(sys16_textmode==0){
  365.         SET_TILE_INFO( 0, tile_number, (data>>6)&0x7f );
  366.     }
  367.     else{
  368.         SET_TILE_INFO( 0, tile_number, (data>>5)&0x7f );
  369.     }
  370.     if((data&0xff00) >= sys16_fg_priority_value) tile_info.priority = 1;
  371.     else tile_info.priority = 0;
  372. }
  373.  
  374. WRITE_HANDLER( sys16_tileram_w ){
  375.     int oldword = READ_WORD(&sys16_tileram[offset]);
  376.     int newword = COMBINE_WORD(oldword,data);
  377.     if( oldword != newword ){
  378.         int page;
  379.         WRITE_WORD(&sys16_tileram[offset],newword);
  380.         offset = offset/2;
  381.         page = offset/(64*32);
  382.         offset = offset%(64*32);
  383.  
  384.         if( sys16_bg_page[0]==page ) tilemap_mark_tile_dirty( background, offset+64*32*0 );
  385.         if( sys16_bg_page[1]==page ) tilemap_mark_tile_dirty( background, offset+64*32*1 );
  386.         if( sys16_bg_page[2]==page ) tilemap_mark_tile_dirty( background, offset+64*32*2 );
  387.         if( sys16_bg_page[3]==page ) tilemap_mark_tile_dirty( background, offset+64*32*3 );
  388.  
  389.         if( sys16_fg_page[0]==page ) tilemap_mark_tile_dirty( foreground, offset+64*32*0 );
  390.         if( sys16_fg_page[1]==page ) tilemap_mark_tile_dirty( foreground, offset+64*32*1 );
  391.         if( sys16_fg_page[2]==page ) tilemap_mark_tile_dirty( foreground, offset+64*32*2 );
  392.         if( sys16_fg_page[3]==page ) tilemap_mark_tile_dirty( foreground, offset+64*32*3 );
  393.  
  394.         if( sys16_18_mode ){
  395.             if( sys16_bg2_page[0]==page ) tilemap_mark_tile_dirty( background2, offset+64*32*0 );
  396.             if( sys16_bg2_page[1]==page ) tilemap_mark_tile_dirty( background2, offset+64*32*1 );
  397.             if( sys16_bg2_page[2]==page ) tilemap_mark_tile_dirty( background2, offset+64*32*2 );
  398.             if( sys16_bg2_page[3]==page ) tilemap_mark_tile_dirty( background2, offset+64*32*3 );
  399.  
  400.             if( sys16_fg2_page[0]==page ) tilemap_mark_tile_dirty( foreground2, offset+64*32*0 );
  401.             if( sys16_fg2_page[1]==page ) tilemap_mark_tile_dirty( foreground2, offset+64*32*1 );
  402.             if( sys16_fg2_page[2]==page ) tilemap_mark_tile_dirty( foreground2, offset+64*32*2 );
  403.             if( sys16_fg2_page[3]==page ) tilemap_mark_tile_dirty( foreground2, offset+64*32*3 );
  404.         }
  405.     }
  406. }
  407.  
  408. READ_HANDLER( sys16_tileram_r ){
  409.     return READ_WORD (&sys16_tileram[offset]);
  410. }
  411.  
  412. /***************************************************************************/
  413.  
  414. static void get_text_tile_info( int offset ){
  415.     const UINT16 *source = (UINT16 *)sys16_textram;
  416.     int tile_number = source[offset];
  417.     int pri = tile_number >> 8;
  418.     if(sys16_textmode==0){
  419.         SET_TILE_INFO( 0, (tile_number&0x1ff) + sys16_tile_bank0 * 0x1000, (tile_number>>9)%8 );
  420.     }
  421.     else{
  422.         SET_TILE_INFO( 0, (tile_number&0xff)  + sys16_tile_bank0 * 0x1000, (tile_number>>8)%8 );
  423.     }
  424.     if(pri>=sys16_textlayer_lo_min && pri<=sys16_textlayer_lo_max)
  425.         tile_info.priority = 1;
  426.     if(pri>=sys16_textlayer_hi_min && pri<=sys16_textlayer_hi_max)
  427.         tile_info.priority = 0;
  428. }
  429.  
  430. WRITE_HANDLER( sys16_textram_w ){
  431.     int oldword = READ_WORD(&sys16_textram[offset]);
  432.     int newword = COMBINE_WORD(oldword,data);
  433.     if( oldword != newword ){
  434.         WRITE_WORD(&sys16_textram[offset],newword);
  435.         tilemap_mark_tile_dirty( text_layer, offset/2 );
  436.     }
  437. }
  438.  
  439. READ_HANDLER( sys16_textram_r ){
  440.     return READ_WORD (&sys16_textram[offset]);
  441. }
  442.  
  443. /***************************************************************************/
  444.  
  445. void sys16_vh_stop( void ){
  446.  
  447. #ifdef SPACEHARRIER_OFFSETS
  448.     if(spaceharrier_patternoffsets) free(spaceharrier_patternoffsets);
  449.     spaceharrier_patternoffsets=0;
  450. #endif
  451. }
  452.  
  453. int sys16_vh_start( void ){
  454.     if( !sys16_bg1_trans )
  455.         background = tilemap_create(
  456.             get_bg_tile_info,
  457.             sys16_bg_map,
  458.             TILEMAP_OPAQUE,
  459.             8,8,
  460.             64*2,32*2 );
  461.     else
  462.         background = tilemap_create(
  463.             get_bg_tile_info,
  464.             sys16_bg_map,
  465.             TILEMAP_TRANSPARENT,
  466.             8,8,
  467.             64*2,32*2 );
  468.  
  469.     foreground = tilemap_create(
  470.         get_fg_tile_info,
  471.         sys16_bg_map,
  472.         TILEMAP_TRANSPARENT,
  473.         8,8,
  474.         64*2,32*2 );
  475.  
  476.     text_layer = tilemap_create(
  477.         get_text_tile_info,
  478.         sys16_text_map,
  479.         TILEMAP_TRANSPARENT,
  480.         8,8,
  481.         40,28 );
  482.  
  483.     sprite_list = sprite_list_create( NUM_SPRITES, SPRITE_LIST_BACK_TO_FRONT | SPRITE_LIST_RAW_DATA );
  484.  
  485.     sprite_set_shade_table(shade_table);
  486.  
  487.     if( background && foreground && text_layer && sprite_list ){
  488.         /* initialize all entries to black - needed for Golden Axe*/
  489.         int i;
  490.         for( i=0; i<Machine->drv->total_colors; i++ ){
  491.             palette_change_color( i, 0,0,0 );
  492.         }
  493. #ifdef TRANSPARENT_SHADOWS
  494.         memset(&palette_used_colors[0], PALETTE_COLOR_UNUSED, Machine->drv->total_colors);
  495.         if (Machine->scrbitmap->depth == 8) /* 8 bit shadows */
  496.         {
  497.             int j,color;
  498.             for(j = 0, i = Machine->drv->total_colors/2;j<sys16_MaxShadowColors;i++,j++)
  499.             {
  500.                 color=j * 160 / (sys16_MaxShadowColors-1);
  501.                 color=color | 0x04;
  502.                 palette_change_color(i, color, color, color);
  503.             }
  504.         }
  505.         if(sys16_MaxShadowColors==32)
  506.             sys16_MaxShadowColors_Shift = ShadowColorsShift;
  507.         else if(sys16_MaxShadowColors==16)
  508.             sys16_MaxShadowColors_Shift = ShadowColorsShift+1;
  509.  
  510. #endif
  511.         for(i=0;i<MAXCOLOURS;i++){
  512.             sys16_palettedirty[i]=0;
  513.         }
  514.         sys16_freezepalette=0;
  515.  
  516.         sprite_list->max_priority = 3;
  517.         sprite_list->sprite_type = SPRITE_TYPE_ZOOM;
  518.  
  519.         if(sys16_bg1_trans) background->transparent_pen = 0;
  520.         foreground->transparent_pen = 0;
  521.         text_layer->transparent_pen = 0;
  522.  
  523.         sys16_tile_bank0 = 0;
  524.         sys16_tile_bank1 = 1;
  525.  
  526.         sys16_fg_scrollx = 0;
  527.         sys16_fg_scrolly = 0;
  528.  
  529.         sys16_bg_scrollx = 0;
  530.         sys16_bg_scrolly = 0;
  531.  
  532.         sys16_refreshenable = 1;
  533.         sys16_clear_screen = 0;
  534.  
  535.         /* common defaults */
  536.         sys16_update_proc = 0;
  537.         sys16_spritesystem = 1;
  538.         sys16_sprxoffset = -0xb8;
  539.         sys16_textmode = 0;
  540.         sys16_bgxoffset = 0;
  541.         sys16_dactype = 0;
  542.         sys16_bg_priority_mode=0;
  543.         sys16_fg_priority_mode=0;
  544.         sys16_spritelist_end=0xffff;
  545.         sys16_tilebank_switch=0x1000;
  546.  
  547.         // Defaults for sys16 games
  548.         sys16_textlayer_lo_min=0;
  549.         sys16_textlayer_lo_max=0x7f;
  550.         sys16_textlayer_hi_min=0x80;
  551.         sys16_textlayer_hi_max=0xff;
  552.  
  553.         sys16_18_mode=0;
  554.  
  555. #ifdef GAMMA_ADJUST
  556.         {
  557.             static float sys16_orig_gamma=0;
  558.             static float sys16_set_gamma=0;
  559.             float cur_gamma=osd_get_gamma();
  560.  
  561.             if(sys16_orig_gamma == 0)
  562.             {
  563.                 sys16_orig_gamma = cur_gamma;
  564.                 sys16_set_gamma = cur_gamma - 0.35;
  565.                 if (sys16_set_gamma < 0.5) sys16_set_gamma = 0.5;
  566.                 if (sys16_set_gamma > 2.0) sys16_set_gamma = 2.0;
  567.                 osd_set_gamma(sys16_set_gamma);
  568.             }
  569.             else
  570.             {
  571.                 if(sys16_orig_gamma == cur_gamma)
  572.                 {
  573.                     osd_set_gamma(sys16_set_gamma);
  574.                 }
  575.             }
  576.         }
  577. #endif
  578.         return 0;
  579.     }
  580.     return 1;
  581. }
  582.  
  583. int sys16_ho_vh_start( void ){
  584.     int ret;
  585.     sys16_bg1_trans=1;
  586.     ret = sys16_vh_start();
  587.     if(ret) return 1;
  588.  
  589.     sys16_textlayer_lo_min=0;
  590.     sys16_textlayer_lo_max=0;
  591.     sys16_textlayer_hi_min=0;
  592.     sys16_textlayer_hi_max=0xff;
  593.  
  594.     sys16_bg_priority_mode=-1;
  595.     sys16_bg_priority_value=0x1800;
  596.     sys16_fg_priority_value=0x2000;
  597.     return 0;
  598. }
  599.  
  600. int sys16_or_vh_start( void ){
  601.     int ret;
  602.     sys16_bg1_trans=1;
  603.     ret = sys16_vh_start();
  604.     if(ret) return 1;
  605.  
  606.     sys16_textlayer_lo_min=0;
  607.     sys16_textlayer_lo_max=0;
  608.     sys16_textlayer_hi_min=0;
  609.     sys16_textlayer_hi_max=0xff;
  610.  
  611.     sys16_bg_priority_mode=-1;
  612.     sys16_bg_priority_value=0x1800;
  613.     sys16_fg_priority_value=0x2000;
  614.     return 0;
  615. }
  616.  
  617.  
  618. int sys18_vh_start( void ){
  619.     int ret;
  620.     sys16_bg1_trans=1;
  621.  
  622.     background2 = tilemap_create(
  623.         get_bg2_tile_info,
  624.         sys16_bg_map,
  625.         TILEMAP_OPAQUE,
  626.         8,8,
  627.         64*2,32*2 );
  628.  
  629.     foreground2 = tilemap_create(
  630.         get_fg2_tile_info,
  631.         sys16_bg_map,
  632.         TILEMAP_TRANSPARENT,
  633.         8,8,
  634.         64*2,32*2 );
  635.  
  636.     if( background2 && foreground2)
  637.     {
  638.         ret = sys16_vh_start();
  639.         if(ret) return 1;
  640.  
  641.         foreground2->transparent_pen = 0;
  642.  
  643.         if(sys18_splittab_fg_x)
  644.         {
  645.             tilemap_set_scroll_rows( foreground , 64 );
  646.             tilemap_set_scroll_rows( foreground2 , 64 );
  647.         }
  648.         if(sys18_splittab_bg_x)
  649.         {
  650.             tilemap_set_scroll_rows( background , 64 );
  651.             tilemap_set_scroll_rows( background2 , 64 );
  652.         }
  653.  
  654.         sys16_textlayer_lo_min=0;
  655.         sys16_textlayer_lo_max=0x1f;
  656.         sys16_textlayer_hi_min=0x20;
  657.         sys16_textlayer_hi_max=0xff;
  658.  
  659.         sys16_18_mode=1;
  660.         sys16_bg_priority_mode=3;
  661.         sys16_fg_priority_mode=3;
  662.         sys16_bg_priority_value=0x1800;
  663.         sys16_fg_priority_value=0x2000;
  664.         return 0;
  665.     }
  666.     return 1;
  667. }
  668.  
  669.  
  670. /***************************************************************************/
  671.  
  672. static void get_sprite_info( void ){
  673.     const unsigned short *base_pal = Machine->gfx[0]->colortable + 1024;
  674.     const unsigned char *base_gfx = memory_region(REGION_GFX2);
  675.  
  676.     UINT16 *source = (UINT16 *)sys16_spriteram;
  677.     struct sprite *sprite = sprite_list->sprite;
  678.     const struct sprite *finish = sprite + NUM_SPRITES;
  679.  
  680.     int passshot_y=0;
  681.     int passshot_width=0;
  682.  
  683. #ifdef SYS16_DEBUG
  684.     int dump_spritedata=0;
  685.     if(keyboard_pressed_memory(KEYCODE_W))
  686.     {
  687.         dump_spritedata=1;
  688.         logerror("sprites\n");
  689.     }
  690. #endif
  691.     switch( sys16_spritesystem  ){
  692.         case 1: /* standard sprite hardware (Shinobi, Altered Beast, Golden Axe, ...) */
  693. /*
  694.     0    bottom--    top-----    (screen coordinates)
  695.     1    ???????X    XXXXXXXX    (screen coordinate)
  696.     2    ???????F    FWWWWWWW    (flipx, flipy, logical width)
  697.     3    TTTTTTTT    TTTTTTTT    (pen data)
  698.     4    ????BBBB    PPCCCCCC    (attributes: bank, priority, color)
  699.     5    ??????ZZ    ZZZZZZZZ    zoomx
  700.     6    ??????ZZ    ZZZZZZZZ    zoomy (defaults to zoomx)
  701.     7    ?                        "sprite offset"
  702. */
  703.         while( sprite<finish ){
  704.             UINT16 ypos = source[0];
  705.             UINT16 width = source[2];
  706.             int top = ypos&0xff;
  707.             int bottom = ypos>>8;
  708.  
  709.             if( bottom == 0xff || width ==sys16_spritelist_end){ /* end of spritelist marker */
  710.                 do {
  711.                     sprite->flags = 0;
  712.                     sprite++;
  713.                 } while( sprite<finish );
  714.                 break;
  715.             }
  716.             sprite->flags = 0;
  717.  
  718.             if(bottom !=0 && bottom > top)
  719.             {
  720.                 UINT16 attributes = source[4];
  721.                 UINT16 zoomx = source[5]&0x3ff;
  722.                 UINT16 zoomy = (source[6]&0x3ff);
  723.                 int gfx = source[3]*4;
  724.  
  725. #ifdef SYS16_DEBUG
  726.                 if(dump_spritedata) logerror("0:%4x  1:%4x  2:%4x  3:%4x  4:%4x  5:%4x  6:%4x  7:%4x\n",
  727.                         source[0],source[1],source[2],source[3],source[4],source[5],source[6],source[7]);
  728. #endif
  729.  
  730.                 if( zoomy==0 || source[6]==0xffff ) zoomy = zoomx; /* if zoomy is 0, use zoomx instead */
  731.  
  732.                 sprite->x = source[1] + sys16_sprxoffset;
  733.                 sprite->y = top;
  734.                 sprite->priority = 3-((attributes>>6)&0x3);
  735.                 sprite->pal_data = base_pal + ((attributes&0x3f)<<4);
  736.  
  737.                 sprite->total_height = bottom-top;
  738.                 sprite->tile_height = sprite->total_height*(0x400+zoomy)/0x400;
  739.  
  740.                 sprite->line_offset = (width&0x7f)*4;
  741.  
  742.                 sprite->flags = SPRITE_VISIBLE;
  743.                 if( width&0x100 ) sprite->flags |= SPRITE_FLIPX;
  744.                 if( width&0x080 ) sprite->flags |= SPRITE_FLIPY;
  745.  
  746. #ifdef TRANSPARENT_SHADOWS
  747.                 if ((attributes&0x3f)==0x3f)    // shadow sprite
  748.                     sprite->flags|= SPRITE_SHADOW;
  749. #endif
  750.  
  751.                 if( sprite->flags&SPRITE_FLIPY ){
  752.                     sprite->line_offset = 512-sprite->line_offset;
  753.                     if( sprite->flags&SPRITE_FLIPX ){
  754.                         gfx += 4 - sprite->line_offset*(sprite->tile_height+1);
  755.                     }
  756.                     else {
  757.                         gfx -= sprite->line_offset*sprite->tile_height;
  758.                     }
  759.                 }
  760.                 else {
  761.                     if( sprite->flags&SPRITE_FLIPX ){
  762.                         gfx += 4;
  763.                     }
  764.                     else {
  765.                         gfx += sprite->line_offset;
  766.                     }
  767.                 }
  768.  
  769.                 sprite->tile_width = sprite->line_offset;
  770.                 sprite->total_width = sprite->tile_width*(0x800-zoomx)/0x800;
  771.                 sprite->pen_data = base_gfx + (gfx &0x3ffff) + (sys16_obj_bank[(attributes>>8)&0xf] << 17);
  772.  
  773.             }
  774.  
  775.             sprite++;
  776.             source += 8;
  777.         }
  778.         break;
  779.  
  780.         case 8: /* Passing shot 4p */
  781.             passshot_y=-0x23;
  782.             passshot_width=1;
  783.         case 0: /* Passing shot */
  784. /*
  785.     0    ???????X    XXXXXXXX    (screen coordinate)
  786.     1    bottom--    top-----    (screen coordinates)
  787.     2    XTTTTTTT    YTTTTTTT    (pen data, flipx, flipy)
  788.     3    ????????    ?WWWWWWW    (logical width)
  789.     4    ??????ZZ    ZZZZZZZZ    zoom
  790.     5    PP???CCC    BBBB????    (attributes: bank, priority, color)
  791.     6,7    (unused)
  792. */
  793.         while( sprite<finish ){
  794.             UINT16 attributes = source[5];
  795.             UINT16 ypos = source[1];
  796.             int bottom = (ypos>>8)+passshot_y;
  797.             int top = (ypos&0xff)+passshot_y;
  798.             sprite->flags = 0;
  799.  
  800.             if( bottom>top && ypos!=0xffff ){
  801.                 int bank = (attributes>>4)&0xf;
  802.                 UINT16 number = source[2];
  803.                 UINT16 width = source[3];
  804.  
  805.                 int zoom = source[4]&0x3ff;
  806.                 int xpos = source[0] + sys16_sprxoffset;
  807.  
  808. #ifdef SYS16_DEBUG
  809.                 if(dump_spritedata) logerror("0:%4x  1:%4x  2:%4x  3:%4x  4:%4x  5:%4x  6:%4x  7:%4x\n",
  810.                         source[0],source[1],source[2],source[3],source[4],source[5],source[6],source[7]);
  811. #endif
  812.                 sprite->priority = 3-((attributes>>14)&0x3);
  813.                 if(passshot_width) /* 4 player bootleg version */
  814.                 {
  815.                     width=-width;
  816.                     number-=width*(bottom-top-1)-1;
  817.                 }
  818.  
  819.                 if( number & 0x8000 ) sprite->flags |= SPRITE_FLIPX;
  820.                 if( width  & 0x0080 ) sprite->flags |= SPRITE_FLIPY;
  821.                 sprite->flags |= SPRITE_VISIBLE;
  822.                 sprite->pal_data = base_pal + ((attributes>>4)&0x3f0);
  823.                 sprite->total_height = bottom - top;
  824.                 sprite->tile_height = sprite->total_height*(0x400+zoom)/0x400;
  825.  
  826. #ifdef TRANSPARENT_SHADOWS
  827.                 if (((attributes>>8)&0x3f)==0x3f)    // shadow sprite
  828.                     sprite->flags|= SPRITE_SHADOW;
  829. #endif
  830.                 width &= 0x7f;
  831.  
  832.                 if( sprite->flags&SPRITE_FLIPY ) width = 0x80-width;
  833.  
  834.                 sprite->tile_width = sprite->line_offset = width*4;
  835.  
  836.                 if( sprite->flags&SPRITE_FLIPX ){
  837.                     bank = (bank-1) & 0xf;
  838.                     if( sprite->flags&SPRITE_FLIPY ){
  839.                         xpos += 4;
  840.                     }
  841.                     else {
  842.                         number += 1-width;
  843.                     }
  844.                 }
  845.                 sprite->pen_data = base_gfx + number*4 + (sys16_obj_bank[bank] << 17);
  846.  
  847.                 if( sprite->flags&SPRITE_FLIPY ){
  848.                     sprite->pen_data -= sprite->tile_height*sprite->tile_width;
  849.                     if( sprite->flags&SPRITE_FLIPX ) sprite->pen_data += 2;
  850.                 }
  851.  
  852.                 sprite->x = xpos;
  853.                 sprite->y = top+2;
  854.  
  855.                 if( sprite->flags&SPRITE_FLIPY ){
  856.                     if( sprite->flags&SPRITE_FLIPX ){
  857.                         sprite->tile_width-=4;
  858.                         sprite->pen_data+=4;
  859.                     }
  860.                     else {
  861.                         sprite->pen_data += sprite->line_offset;
  862.                     }
  863.                 }
  864.  
  865.                 sprite->total_width = sprite->tile_width*(0x800-zoom)/0x800;
  866.             }
  867.             sprite++;
  868.             source += 8;
  869.         }
  870.         break;
  871.  
  872.         case 4: // Aurail
  873. /*
  874.     0    bottom--    top-----    (screen coordinates)
  875.     1    ???????X    XXXXXXXX    (screen coordinate)
  876.     2    ???????F    FWWWWWWW    (flipx, flipy, logical width)
  877.     3    TTTTTTTT    TTTTTTTT    (pen data)
  878.     4    ????BBBB    PPCCCCCC    (attributes: bank, priority, color)
  879.     5    ??????ZZ    ZZZZZZZZ    zoomx
  880.     6    ??????ZZ    ZZZZZZZZ    zoomy (defaults to zoomx)
  881.     7    ?                        "sprite offset"
  882. */
  883.         while( sprite<finish ){
  884.             UINT16 ypos = source[0];
  885.             UINT16 width = source[2];
  886.             UINT16 attributes = source[4];
  887.             int top = ypos&0xff;
  888.             int bottom = ypos>>8;
  889.  
  890.             if( width == sys16_spritelist_end) {
  891.                 do {
  892.                     sprite->flags = 0;
  893.                     sprite++;
  894.                 } while( sprite<finish );
  895.                 break;
  896.             }
  897.             sprite->flags = 0;
  898. #ifdef TRANSPARENT_SHADOWS
  899.             if(bottom !=0 && bottom > top)
  900. #else
  901.             if(bottom !=0 && bottom > top && (attributes&0x3f) !=0x3f)
  902. #endif
  903.             {
  904.                 UINT16 zoomx = source[5]&0x3ff;
  905.                 UINT16 zoomy = (source[6]&0x3ff);
  906.                 int gfx = source[3]*4;
  907.  
  908. #ifdef SYS16_DEBUG
  909.                 if(dump_spritedata) logerror("0:%4x  1:%4x  2:%4x  3:%4x  4:%4x  5:%4x  6:%4x  7:%4x\n",
  910.                         source[0],source[1],source[2],source[3],source[4],source[5],source[6],source[7]);
  911. #endif
  912.  
  913.                 if( zoomy==0 ) zoomy = zoomx; /* if zoomy is 0, use zoomx instead */
  914.                 sprite->pal_data = base_pal + ((attributes&0x3f)<<4);
  915.  
  916.                 sprite->x = source[1] + sys16_sprxoffset;;
  917.                 sprite->y = top;
  918.                 sprite->priority = 3-((attributes>>6)&0x3);
  919.  
  920.                 sprite->total_height = bottom-top;
  921.                 sprite->tile_height = sprite->total_height*(0x400+zoomy)/0x400;
  922.  
  923.                 sprite->line_offset = (width&0x7f)*4;
  924.  
  925.                 sprite->flags = SPRITE_VISIBLE;
  926.                 if( width&0x100 ) sprite->flags |= SPRITE_FLIPX;
  927.                 if( width&0x080 ) sprite->flags |= SPRITE_FLIPY;
  928. #ifdef TRANSPARENT_SHADOWS
  929.                 if ((attributes&0x3f)==0x3f)    // shadow sprite
  930.                     sprite->flags|= SPRITE_SHADOW;
  931. #endif
  932.  
  933.                 if( sprite->flags&SPRITE_FLIPY ){
  934.                     sprite->line_offset = 512-sprite->line_offset;
  935.                     if( sprite->flags&SPRITE_FLIPX ){
  936.                         gfx += 4 - sprite->line_offset*(sprite->tile_height+1);
  937.                     }
  938.                     else {
  939.                         gfx -= sprite->line_offset*sprite->tile_height;
  940.                     }
  941.                 }
  942.                 else {
  943.                     if( sprite->flags&SPRITE_FLIPX ){
  944.                         gfx += 4;
  945.                     }
  946.                     else {
  947.                         gfx += sprite->line_offset;
  948.                     }
  949.                 }
  950.  
  951.                 sprite->tile_width = sprite->line_offset;
  952.                 sprite->total_width = sprite->tile_width*(0x800-zoomx)/0x800;
  953.                 sprite->pen_data = base_gfx + (gfx &0x3ffff) + (sys16_obj_bank[(attributes>>8)&0xf] << 17);
  954.  
  955.             }
  956.             sprite++;
  957.             source += 8;
  958.         }
  959.         break;
  960.         case 3:    // Fantzone
  961.             {
  962.                 int spr_no=0;
  963.                 while( sprite<finish ){
  964.                     UINT16 ypos = source[0];
  965.                     UINT16 pal=(source[4]>>8)&0x3f;
  966.                     int top = ypos&0xff;
  967.                     int bottom = ypos>>8;
  968.  
  969.                     if( bottom == 0xff ){ /* end of spritelist marker */
  970.                         do {
  971.                             sprite->flags = 0;
  972.                             sprite++;
  973.                         } while( sprite<finish );
  974.                         break;
  975.                     }
  976.                     sprite->flags = 0;
  977.  
  978. #ifdef SYS16_DEBUG
  979.                     if(dump_spritedata) logerror("0:%4x  1:%4x  2:%4x  3:%4x  4:%4x  5:%4x  6:%4x  7:%4x\n",
  980.                             source[0],source[1],source[2],source[3],source[4],source[5],source[6],source[7]);
  981. #endif
  982. #ifdef TRANSPARENT_SHADOWS
  983.                     if(bottom !=0 && bottom > top)
  984. #else
  985.                     if(bottom !=0 && bottom > top && pal !=0x3f)
  986. #endif
  987.                     {
  988.                         UINT16 spr_pri=(source[4])&0xf;
  989.                         UINT16 bank=(source[4]>>4) &0xf;
  990.                         UINT16 tsource[4];
  991.                         UINT16 width;
  992.                         int gfx;
  993.  
  994.                         if (spr_no==5 && (source[4]&0x00ff) == 0x0021 &&
  995.                             ((source[3]&0xff00) == 0x5200 || (source[3]&0xff00) == 0x5300)) spr_pri=2; // tears fix for ending boss
  996.  
  997.                         tsource[2]=source[2];
  998.                         tsource[3]=source[3];
  999.  
  1000.                         if((tsource[3] & 0x7f80) == 0x7f80)
  1001.                         {
  1002.                             bank=(bank-1)&0xf;
  1003.                             tsource[3]^=0x8000;
  1004.                         }
  1005.  
  1006.                         tsource[2] &= 0x00ff;
  1007.                         if (tsource[3]&0x8000)
  1008.                         { // reverse
  1009.                             tsource[2] |= 0x0100;
  1010.                             tsource[3] &= 0x7fff;
  1011.                         }
  1012.  
  1013.                         gfx = tsource[3]*4;
  1014.                         width = tsource[2];
  1015.                         top++;
  1016.                         bottom++;
  1017.  
  1018.                         sprite->x = source[1] + sys16_sprxoffset;
  1019.                         if(sprite->x > 0x140) sprite->x-=0x200;
  1020.                         sprite->y = top;
  1021.                         sprite->priority = 3-spr_pri;
  1022.                         sprite->pal_data = base_pal + (pal<<4);
  1023.  
  1024.                         sprite->total_height = bottom-top;
  1025.                         sprite->tile_height = sprite->total_height;
  1026.  
  1027.                         sprite->line_offset = (width&0x7f)*4;
  1028.  
  1029.                         sprite->flags = SPRITE_VISIBLE;
  1030.                         if( width&0x100 ) sprite->flags |= SPRITE_FLIPX;
  1031.                         if( width&0x080 ) sprite->flags |= SPRITE_FLIPY;
  1032. #ifdef TRANSPARENT_SHADOWS
  1033.                         if (pal==0x3f)    // shadow sprite
  1034.                             sprite->flags|= SPRITE_SHADOW;
  1035. #endif
  1036.  
  1037.                         if( sprite->flags&SPRITE_FLIPY ){
  1038.                             sprite->line_offset = 512-sprite->line_offset;
  1039.                             if( sprite->flags&SPRITE_FLIPX ){
  1040.                                 gfx += 4 - sprite->line_offset*(sprite->tile_height+1);
  1041.                             }
  1042.                             else {
  1043.                                 gfx -= sprite->line_offset*sprite->tile_height;
  1044.                             }
  1045.                         }
  1046.                         else {
  1047.                             if( sprite->flags&SPRITE_FLIPX ){
  1048.                                 gfx += 4;
  1049.                             }
  1050.                             else {
  1051.                                 gfx += sprite->line_offset;
  1052.                             }
  1053.                         }
  1054.  
  1055.                         sprite->tile_width = sprite->line_offset;
  1056.                         if(width==0) sprite->tile_width=320;            // fixes laser
  1057.                         sprite->total_width = sprite->tile_width;
  1058.                         sprite->pen_data = base_gfx + (gfx &0x3ffff) + (sys16_obj_bank[bank] << 17);
  1059.  
  1060.                     }
  1061.  
  1062.                     source+=8;
  1063.                     sprite++;
  1064.                     spr_no++;
  1065.                 }
  1066.             }
  1067.             break;
  1068.         case 2: // Quartet2 /Alexkidd + others
  1069.         while( sprite<finish ){
  1070.             UINT16 ypos = source[0];
  1071.             int top = ypos&0xff;
  1072.             int bottom = ypos>>8;
  1073.  
  1074.             if( bottom == 0xff ){ /* end of spritelist marker */
  1075.                 do {
  1076.                     sprite->flags = 0;
  1077.                     sprite++;
  1078.                 } while( sprite<finish );
  1079.                 break;
  1080.             }
  1081.             sprite->flags = 0;
  1082.  
  1083.             if(bottom !=0 && bottom > top)
  1084.             {
  1085.                 UINT16 spr_pri=(source[4])&0xf;
  1086.                 UINT16 bank=(source[4]>>4) &0xf;
  1087.                 UINT16 pal=(source[4]>>8)&0x3f;
  1088.                 UINT16 tsource[4];
  1089.                 UINT16 width;
  1090.                 int gfx;
  1091.  
  1092. #ifdef SYS16_DEBUG
  1093.                 if(dump_spritedata) logerror("0:%4x  1:%4x  2:%4x  3:%4x  4:%4x  5:%4x  6:%4x  7:%4x\n",
  1094.                         source[0],source[1],source[2],source[3],source[4],source[5],source[6],source[7]);
  1095. #endif
  1096.  
  1097.                 tsource[2]=source[2];
  1098.                 tsource[3]=source[3];
  1099. #ifndef TRANSPARENT_SHADOWS
  1100.                 if (pal==0x3f)    // shadow sprite
  1101.                     pal=(bank<<1);
  1102. #endif
  1103.  
  1104.                 if((tsource[3] & 0x7f80) == 0x7f80)
  1105.                 {
  1106.                     bank=(bank-1)&0xf;
  1107.                     tsource[3]^=0x8000;
  1108.                 }
  1109.  
  1110.                 tsource[2] &= 0x00ff;
  1111.                 if (tsource[3]&0x8000)
  1112.                 { // reverse
  1113.                     tsource[2] |= 0x0100;
  1114.                     tsource[3] &= 0x7fff;
  1115.                 }
  1116.  
  1117.                 gfx = tsource[3]*4;
  1118.                 width = tsource[2];
  1119.                 top++;
  1120.                 bottom++;
  1121.  
  1122.                 sprite->x = source[1] + sys16_sprxoffset;
  1123.                 if(sprite->x > 0x140) sprite->x-=0x200;
  1124.                 sprite->y = top;
  1125.                 sprite->priority = 3 - spr_pri;
  1126.                 sprite->pal_data = base_pal + (pal<<4);
  1127.  
  1128.                 sprite->total_height = bottom-top;
  1129.                 sprite->tile_height = sprite->total_height;
  1130.  
  1131.                 sprite->line_offset = (width&0x7f)*4;
  1132.  
  1133.                 sprite->flags = SPRITE_VISIBLE;
  1134.                 if( width&0x100 ) sprite->flags |= SPRITE_FLIPX;
  1135.                 if( width&0x080 ) sprite->flags |= SPRITE_FLIPY;
  1136. #ifdef TRANSPARENT_SHADOWS
  1137.                 if (pal==0x3f)    // shadow sprite
  1138.                     sprite->flags|= SPRITE_SHADOW;
  1139. #endif
  1140.  
  1141.                 if( sprite->flags&SPRITE_FLIPY ){
  1142.                     sprite->line_offset = 512-sprite->line_offset;
  1143.                     if( sprite->flags&SPRITE_FLIPX ){
  1144.                         gfx += 4 - sprite->line_offset*(sprite->tile_height+1);
  1145.                     }
  1146.                     else {
  1147.                         gfx -= sprite->line_offset*sprite->tile_height;
  1148.                     }
  1149.                 }
  1150.                 else {
  1151.                     if( sprite->flags&SPRITE_FLIPX ){
  1152.                         gfx += 4;
  1153.                     }
  1154.                     else {
  1155.                         gfx += sprite->line_offset;
  1156.                     }
  1157.                 }
  1158.  
  1159.                 sprite->tile_width = sprite->line_offset;
  1160.                 sprite->total_width = sprite->tile_width;
  1161.                 sprite->pen_data = base_gfx + (gfx &0x3ffff) + (sys16_obj_bank[bank] << 17);
  1162.             }
  1163.  
  1164.             source+=8;
  1165.             sprite++;
  1166.         }
  1167.         break;
  1168.         case 5: // Hang-On
  1169.         while( sprite<finish ){
  1170.             UINT16 ypos = source[0];
  1171.             int top = ypos&0xff;
  1172.             int bottom = ypos>>8;
  1173.  
  1174.             if( bottom == 0xff ){ /* end of spritelist marker */
  1175.                 do {
  1176.                     sprite->flags = 0;
  1177.                     sprite++;
  1178.                 } while( sprite<finish );
  1179.                 break;
  1180.             }
  1181.             sprite->flags = 0;
  1182.  
  1183.             if(bottom !=0 && bottom > top)
  1184.             {
  1185.                 UINT16 bank=(source[1]>>12);
  1186.                 UINT16 pal=(source[4]>>8)&0x3f;
  1187.                 UINT16 tsource[4];
  1188.                 UINT16 width;
  1189.                 int gfx;
  1190.                 int zoomx,zoomy;
  1191.  
  1192. #ifdef SYS16_DEBUG
  1193.                 if(dump_spritedata) logerror("0:%4x  1:%4x  2:%4x  3:%4x  4:%4x  5:%4x  6:%4x  7:%4x\n",
  1194.                         source[0],source[1],source[2],source[3],source[4],source[5],source[6],source[7]);
  1195. #endif
  1196.  
  1197.                 tsource[2]=source[2];
  1198.                 tsource[3]=source[3];
  1199.  
  1200.                 zoomx=((source[4]>>2) & 0x3f) *(1024/64);
  1201.                 zoomy = (1060*zoomx)/(2048-zoomx);
  1202.  
  1203. //                if (pal==0x3f)    // ????????????
  1204. //                    pal=(bank<<1);
  1205.  
  1206.                 if((tsource[3] & 0x7f80) == 0x7f80)
  1207.                 {
  1208.                     bank=(bank-1)&0xf;
  1209.                     tsource[3]^=0x8000;
  1210.                 }
  1211.  
  1212.                 if (tsource[3]&0x8000)
  1213.                 { // reverse
  1214.                     tsource[2] |= 0x0100;
  1215.                     tsource[3] &= 0x7fff;
  1216.                 }
  1217.  
  1218.                 gfx = tsource[3]*4;
  1219.                 width = tsource[2];
  1220.  
  1221.                 sprite->x = ((source[1] & 0x3ff) + sys16_sprxoffset);
  1222.                 if(sprite->x >= 0x200) sprite->x-=0x200;
  1223.                 sprite->y = top;
  1224.                 sprite->priority = 0;
  1225.                 sprite->pal_data = base_pal + (pal<<4);
  1226.  
  1227.                 sprite->total_height = bottom-top;
  1228.                 sprite->tile_height = sprite->total_height*(0x400+zoomy)/0x400;
  1229.  
  1230.                 sprite->line_offset = (width&0x7f)*4;
  1231.  
  1232.                 sprite->flags = SPRITE_VISIBLE;
  1233.                 if( width&0x100 ) sprite->flags |= SPRITE_FLIPX;
  1234.                 if( width&0x080 ) sprite->flags |= SPRITE_FLIPY;
  1235.  
  1236.  
  1237. //                sprite->flags|= SPRITE_PARTIAL_SHADOW;
  1238. //                sprite->shadow_pen=10;
  1239.  
  1240.                 if( sprite->flags&SPRITE_FLIPY ){
  1241.                     sprite->line_offset = 512-sprite->line_offset;
  1242.                     if( sprite->flags&SPRITE_FLIPX ){
  1243.                         gfx += 4 - sprite->line_offset*(sprite->tile_height+1);
  1244.                     }
  1245.                     else {
  1246.                         gfx -= sprite->line_offset*sprite->tile_height;
  1247.                     }
  1248.                 }
  1249.                 else {
  1250.                     if( sprite->flags&SPRITE_FLIPX ){
  1251.                         gfx += 4;
  1252.                     }
  1253.                     else {
  1254.                         gfx += sprite->line_offset;
  1255.                     }
  1256.                 }
  1257.  
  1258.                 sprite->tile_width = sprite->line_offset;
  1259.                 sprite->total_width = sprite->tile_width*(0x0800 - zoomx)/0x800;
  1260.                 sprite->pen_data = base_gfx + (gfx &0x3ffff) + (sys16_obj_bank[bank] << 17);
  1261.  
  1262.             }
  1263.  
  1264.             source+=8;
  1265.             sprite++;
  1266.         }
  1267.         break;
  1268.         case 6: // Space Harrier
  1269.         while( sprite<finish ){
  1270.             UINT16 ypos = source[0];
  1271.             int top = ypos&0xff;
  1272.             int bottom = ypos>>8;
  1273.  
  1274.             if( bottom == 0xff ){ /* end of spritelist marker */
  1275.                 do {
  1276.                     sprite->flags = 0;
  1277.                     sprite++;
  1278.                 } while( sprite<finish );
  1279.                 break;
  1280.             }
  1281.             sprite->flags = 0;
  1282.  
  1283.             if(bottom !=0 && bottom > top)
  1284.             {
  1285.                 UINT16 bank=(source[1]>>12);
  1286.                 UINT16 pal=(source[2]>>8)&0x3f;
  1287.                 UINT16 tsource[4];
  1288.                 UINT16 width;
  1289.                 int gfx;
  1290.                 int zoomx,zoomy;
  1291.  
  1292. #ifdef SYS16_DEBUG
  1293.                 if(dump_spritedata) logerror("0:%4x  1:%4x  2:%4x  3:%4x  4:%4x  5:%4x  6:%4x  7:%4x\n",
  1294.                         source[0],source[1],source[2],source[3],source[4],source[5],source[6],source[7]);
  1295. #endif
  1296.  
  1297.                 tsource[2]=source[2]&0xff;
  1298.                 tsource[3]=source[3];
  1299.  
  1300.                 zoomx=(source[4] & 0x3f) *(1024/64);
  1301.                 zoomy = (1024*zoomx)/(2048-zoomx);
  1302.  
  1303. #ifndef TRANSPARENT_SHADOWS
  1304.                 if (pal==0x3f)    // shadow sprite
  1305.                     pal=(bank<<1);
  1306. #endif
  1307.  
  1308.                 if((tsource[3] & 0x7f80) == 0x7f80)
  1309.                 {
  1310.                     bank=(bank-1)&0xf;
  1311.                     tsource[3]^=0x8000;
  1312.                 }
  1313.  
  1314.                 if (tsource[3]&0x8000)
  1315.                 { // reverse
  1316.                     tsource[2] |= 0x0100;
  1317.                     tsource[3] &= 0x7fff;
  1318.                 }
  1319.  
  1320.                 gfx = tsource[3]*4;
  1321.                 width = tsource[2];
  1322.  
  1323.                 sprite->x = ((source[1] & 0x3ff) + sys16_sprxoffset);
  1324.                 if(sprite->x >= 0x200) sprite->x-=0x200;
  1325.                 sprite->y = top+1;
  1326.                 sprite->priority = 0;
  1327.                 sprite->pal_data = base_pal + (pal<<4);
  1328.  
  1329.                 sprite->total_height = bottom-top;
  1330. //                sprite->tile_height = sprite->total_height*(0x400+zoomy)/0x400;
  1331.                 sprite->tile_height = ((sprite->total_height)<<4|0xf)*(0x400+zoomy)/0x4000;
  1332.  
  1333.                 sprite->line_offset = (width&0x7f)*4;
  1334.  
  1335.                 sprite->flags = SPRITE_VISIBLE;
  1336.                 if( width&0x100 ) sprite->flags |= SPRITE_FLIPX;
  1337.                 if( width&0x080 ) sprite->flags |= SPRITE_FLIPY;
  1338.  
  1339. #ifdef TRANSPARENT_SHADOWS
  1340.                 if (sys16_sh_shadowpal == 0)        // space harrier
  1341.                 {
  1342.                     if (pal==sys16_sh_shadowpal)    // shadow sprite
  1343.                         sprite->flags|= SPRITE_SHADOW;
  1344.                     // I think this looks better, but I'm sure it's wrong.
  1345. //                    else if(READ_WORD(&paletteram[2048+pal*2+20]) == 0)
  1346. //                    {
  1347. //                        sprite->flags|= SPRITE_PARTIAL_SHADOW;
  1348. //                        sprite->shadow_pen=10;
  1349. //                    }
  1350.                 }
  1351.                 else                                // enduro
  1352.                 {
  1353.                     sprite->flags|= SPRITE_PARTIAL_SHADOW;
  1354.                     sprite->shadow_pen=10;
  1355.                 }
  1356. #endif
  1357.                 if( sprite->flags&SPRITE_FLIPY ){
  1358.                     sprite->line_offset = 512-sprite->line_offset;
  1359.                     if( sprite->flags&SPRITE_FLIPX ){
  1360.                         gfx += 4 - sprite->line_offset*(sprite->tile_height+1) /*+4*/;
  1361.                     }
  1362.                     else {
  1363.                         gfx -= sprite->line_offset*sprite->tile_height;
  1364.                     }
  1365.                 }
  1366.                 else {
  1367.                     if( sprite->flags&SPRITE_FLIPX ){
  1368.                         gfx += 4 /*+ 4*/;        // +2 ???
  1369.                     }
  1370.                     else {
  1371.                         gfx += sprite->line_offset;
  1372.                     }
  1373.                 }
  1374.  
  1375.                 sprite->line_offset<<=1;
  1376.                 sprite->tile_width = sprite->line_offset;
  1377.                 sprite->total_width = sprite->tile_width*(0x0800 - zoomx)/0x800;
  1378.  
  1379.                 sprite->pen_data = base_gfx + (((gfx &0x3ffff) + (sys16_obj_bank[bank] << 17)) << 1);
  1380.  
  1381.  
  1382. #ifdef SPACEHARRIER_OFFSETS
  1383. // doesn't seem to work properly and I'm not sure why it's needed.
  1384.                 if( !(width & 0x180) && (width & 0x7f))
  1385.                 {
  1386.                     unsigned addr=tsource[3];
  1387.                     unsigned offset_addr= (bank<<12) | (addr>>4);
  1388.                     char rebuild = 0;
  1389.  
  1390.                     if (spaceharrier_patternoffsets[offset_addr]!=0x7f)
  1391.                     {
  1392.                         offset = spaceharrier_patternoffsets[offset_addr];
  1393.                     }
  1394.                     else
  1395.                     { // build pattern offset
  1396.                         unsigned width2=width&0x7f;
  1397.                         UINT8 *p,*p0;
  1398.                         unsigned height=sprite->tile_height;
  1399.                         unsigned width_bytes;
  1400.                         int len_pattern;
  1401.                         int i,j;
  1402.  
  1403.                         len_pattern = height*width2;
  1404.                         if (len_pattern >= 16)
  1405.                         {
  1406.  
  1407.                             len_pattern >>= 4;
  1408.  
  1409.                             // 32 bit sprite hardware ///////////////////////////////////////////
  1410.                             width_bytes = width2<<3;
  1411.                             p0 = (UINT8 *)sprite->pen_data;
  1412.                             /////////////////////////////////////////////////////////////////////
  1413.  
  1414.                             offset=0xe;
  1415.                             for (i=0, p=p0; i<height; i++, p+=width_bytes)
  1416.                             {
  1417.                                 for (j=0; j<width_bytes && j<offset; j++)
  1418.                                 {
  1419.                                     if ((p[j]!=0xff && p[j]!=0x00) /*|| (p[j+1]!=0xff && p[j+1]!=0x00 )*/) break;
  1420.                                 }
  1421.                                 if (j<offset) offset = j;
  1422.                             }
  1423.  
  1424.                             //              printf("rebuild %02x:%04x = %d\n", bank, addr, offset);
  1425.  
  1426.                             p=&spaceharrier_patternoffsets[offset_addr];
  1427.  
  1428.                             offset/=2;
  1429.                             for (i=0; i<len_pattern; i++,p++) *p = offset;
  1430.  
  1431.                             logerror("addr=%04x offset=%4x bank=%02x offset=%d height=%d zoomy=%04x len_pattern=%d width=%d offset_addr=%04x\n", addr, offset, bank, offset, height, zoomy,  len_pattern, width2, offset_addr);
  1432.                         }
  1433.                     }
  1434.                 }
  1435.                 sprite->pen_data += offset*2;
  1436. #endif
  1437.             }
  1438.  
  1439.             source+=8;
  1440.             sprite++;
  1441.         }
  1442.         break;
  1443.         case 7: // Out Run
  1444.         while( sprite<finish ){
  1445.  
  1446.             if( source[0] == 0xffff ){ /* end of spritelist marker */
  1447.                 do {
  1448.                     sprite->flags = 0;
  1449.                     sprite++;
  1450.                 } while( sprite<finish );
  1451.                 break;
  1452.             }
  1453.             sprite->flags = 0;
  1454.  
  1455.             if (!(source[0]&0x4000))
  1456.             {
  1457.                 UINT16 bank=(source[0]>>8)&7;
  1458.                 UINT16 pal=(source[5])&0x7f;
  1459.                 UINT16 width;
  1460.                 int gfx;
  1461.                 int zoom;
  1462.                 int x;
  1463.  
  1464. #ifdef SYS16_DEBUG
  1465.                 if(dump_spritedata) logerror("0:%4x  1:%4x  2:%4x  3:%4x  4:%4x  5:%4x  6:%4x  7:%4x\n",
  1466.                         source[0],source[1],source[2],source[3],source[4],source[5],source[6],source[7]);
  1467. #endif
  1468.  
  1469.                 zoom=source[4]&0xfff;
  1470. //                if (zoom==0x32c) zoom=0x3cf;    //???
  1471.  
  1472.                 if(zoom==0) zoom=1;
  1473.  
  1474.                 if (source[1]&0x8000) bank=(bank+1)&0x7;
  1475.  
  1476.                 gfx = (source[1]&0x7fff)*4;
  1477.                 width = source[2]>>9;
  1478.  
  1479.                 x = (source[2] & 0x1ff);
  1480.  
  1481.                 // patch misplaced sprite on map
  1482. //                if(zoom == 0x3f0 && source[1]==0x142e && (source[0]&0xff)==0x19)
  1483. //                    x-=2;
  1484.  
  1485.                 sprite->y = source[0]&0xff;
  1486.                 sprite->priority = 0;
  1487.                 sprite->pal_data = base_pal + (pal<<4) + 1024;
  1488.  
  1489.                 sprite->total_height = (source[5]>>8)+1;
  1490.                 sprite->tile_height = ((sprite->total_height<<4)| 0xf)*(zoom)/0x2000;
  1491.  
  1492.                 sprite->line_offset = (width&0x7f)*4;
  1493.  
  1494.                 sprite->flags = SPRITE_VISIBLE;
  1495. #ifdef TRANSPARENT_SHADOWS
  1496.                 if(pal==0)
  1497.                     sprite->flags|= SPRITE_SHADOW;
  1498.                 else if(source[3]&0x4000)
  1499. //                if(pal==0 || source[3]&0x4000)
  1500.                 {
  1501.                     sprite->flags|= SPRITE_PARTIAL_SHADOW;
  1502.                     sprite->shadow_pen=10;
  1503.                 }
  1504. #endif
  1505.                 if(!(source[4]&0x2000))
  1506.                 {
  1507.                     if(!(source[4]&0x4000))
  1508.                     {
  1509.                         // Should be drawn right to left, but this should be ok.
  1510.                         x-=(sprite->line_offset*2)*0x200/zoom;
  1511.                         gfx+=4-sprite->line_offset;
  1512.                     }
  1513.                     else
  1514.                     {
  1515.                         int ofs=(sprite->line_offset*2)*0x200/zoom;
  1516.                         x-=ofs;
  1517.                         sprite->flags |= SPRITE_FLIPX;
  1518.  
  1519.                         // x position compensation for rocks in round2R and round4RRR
  1520. /*                        if((source[0]&0xff00)==0x0300)
  1521.                         {
  1522.                             if (source[1]==0xc027)
  1523.                             {
  1524.                                 if ((source[2]>>8)==0x59) x += ofs/2;
  1525.                                 else if ((source[2]>>8)>0x59) x += ofs;
  1526.                             }
  1527.                             else if (source[1]==0xcf73)
  1528.                             {
  1529.                                 if ((source[2]>>8)==0x2d) x += ofs/2;
  1530.                                 else if ((source[2]>>8)>0x2d) x += ofs;
  1531.                             }
  1532.                             else if (source[1]==0xd3046)
  1533.                             {
  1534.                                 if ((source[2]>>8)==0x19) x += ofs/2;
  1535.                                 else if ((source[2]>>8)>0x19) x += ofs;
  1536.                             }
  1537.                             else if (source[1]==0xd44e)
  1538.                             {
  1539.                                 if ((source[2]>>8)==0x0d) x += ofs/2;
  1540.                                 else if ((source[2]>>8)>0x0d) x += ofs;
  1541.                             }
  1542.                             else if (source[1]==0xd490)
  1543.                             {
  1544.                                 if ((source[2]>>8)==0x09) x += ofs/2;
  1545.                                 else if ((source[2]>>8)>0x09) x += ofs;
  1546.                             }
  1547.                         }
  1548. */
  1549.                     }
  1550.                 }
  1551.                 else
  1552.                 {
  1553.                     if(!(source[4]&0x4000))
  1554.                     {
  1555.                         gfx-=sprite->line_offset-4;
  1556.                         sprite->flags |= SPRITE_FLIPX;
  1557.                     }
  1558.                     else
  1559.                     {
  1560.                         if (source[4]&0x8000)
  1561.                         { // patch for car shadow position
  1562.                             if (source[4]==0xe1a9 && source[1]==0x5817)
  1563.                                 x-=2;
  1564.                         }
  1565.                     }
  1566.                 }
  1567.  
  1568.                 sprite->x = x + sys16_sprxoffset;
  1569.  
  1570.                 sprite->line_offset<<=1;
  1571.                 sprite->tile_width = sprite->line_offset;
  1572.                 sprite->total_width = sprite->tile_width*0x200/zoom;
  1573.                 sprite->pen_data = base_gfx + (((gfx &0x3ffff) + (sys16_obj_bank[bank] << 17)) << 1);
  1574.             }
  1575.             source+=8;
  1576.             sprite++;
  1577.         }
  1578.         break;
  1579.     }
  1580. }
  1581.  
  1582. /***************************************************************************/
  1583.  
  1584. static void mark_sprite_colors( void ){
  1585.     unsigned short *source = (unsigned short *)sys16_spriteram;
  1586.     unsigned short *finish = source+NUM_SPRITES*8;
  1587.     int pal_start=1024,pal_size=64;
  1588.  
  1589.     char used[128];
  1590.     memset( used, 0, 128 );
  1591.  
  1592.     switch( sys16_spritesystem ){
  1593.         case 1: /* standard sprite hardware */
  1594.             do{
  1595.                 if( source[0]>>8 == 0xff || source[2] == sys16_spritelist_end) break;
  1596.                 used[source[4]&0x3f] = 1;
  1597.                 source+=8;
  1598.             }while( source<finish );
  1599.             break;
  1600.         case 4: /* Aurail */
  1601.             do{
  1602.                 if( (source[2]) == sys16_spritelist_end) break;
  1603.                 used[source[4]&0x3f] = 1;
  1604.                 source+=8;
  1605.             }while( source<finish );
  1606.             break;
  1607.  
  1608.         case 3:    /* Fantzone */
  1609.         case 5:    /* Hang-On */
  1610.         case 2: /* Quartet2 / alex kidd + others */
  1611.             do{
  1612.                 if( (source[0]>>8) == 0xff ) break;;
  1613.                 used[(source[4]>>8)&0x3f] = 1;
  1614.                 source+=8;
  1615.             }while( source<finish );
  1616.             break;
  1617.         case 6:    /* Space Harrier */
  1618.             do{
  1619.                 if( (source[0]>>8) == 0xff ) break;;
  1620.                 used[(source[2]>>8)&0x3f] = 1;
  1621.                 source+=8;
  1622.             }while( source<finish );
  1623.             break;
  1624.         case 7:    /* Out Run */
  1625.             do{
  1626.                 if( (source[0]) == 0xffff ) break;;
  1627.                 used[(source[5])&0x7f] = 1;
  1628.                 source+=8;
  1629.             }while( source<finish );
  1630.             pal_start=2048;
  1631.             pal_size=128;
  1632.             break;
  1633.         case 0: /* passing shot */
  1634.         case 8: /* passing shot 4p */
  1635.             do{
  1636.                 if( source[1]!=0xffff ) used[(source[5]>>8)&0x3f] = 1;
  1637.                 source+=8;
  1638.             }while( source<finish );
  1639.             break;
  1640.     }
  1641.  
  1642.     {
  1643.         unsigned char *pal = &palette_used_colors[pal_start];
  1644.         int i;
  1645.         for (i = 0; i < pal_size; i++){
  1646.             if ( used[i] ){
  1647.                 pal[0] = PALETTE_COLOR_UNUSED;
  1648.                 memset( &pal[1],PALETTE_COLOR_USED,14 );
  1649.                 pal[15] = PALETTE_COLOR_UNUSED;
  1650.             }
  1651.             else {
  1652.                 memset( pal, PALETTE_COLOR_UNUSED, 16 );
  1653.             }
  1654.             pal += 16;
  1655.         }
  1656.     }
  1657. #ifdef TRANSPARENT_SHADOWS
  1658.     if (Machine->scrbitmap->depth == 8) /* 8 bit shadows */
  1659.     {
  1660.         memset(&palette_used_colors[Machine->drv->total_colors/2], PALETTE_COLOR_USED, sys16_MaxShadowColors);
  1661.     }
  1662.     else if(sys16_MaxShadowColors != 0) /* 16 bit shadows */
  1663.     {
  1664.         /* Mark the shadowed versions of the used pens */
  1665.         memcpy(&palette_used_colors[Machine->drv->total_colors/2], &palette_used_colors[0], Machine->drv->total_colors/2);
  1666.     }
  1667. #endif
  1668. }
  1669.  
  1670. #ifdef TRANSPARENT_SHADOWS
  1671. static void build_shadow_table(void)
  1672. {
  1673.     int i,size;
  1674.     int color_start=Machine->drv->total_colors/2;
  1675.     /* build the shading lookup table */
  1676.     if (Machine->scrbitmap->depth == 8) /* 8 bit shadows */
  1677.     {
  1678.         if(sys16_MaxShadowColors == 0) return;
  1679.         for (i = 0; i < 256; i++)
  1680.         {
  1681.             unsigned char r, g, b;
  1682.             int y;
  1683.             osd_get_pen(i, &r, &g, &b);
  1684.             y = (r * 10 + g * 18 + b * 4) >> sys16_MaxShadowColors_Shift;
  1685.             shade_table[i] = Machine->pens[color_start + y];
  1686.         }
  1687.         for(i=0;i<sys16_MaxShadowColors;i++)
  1688.         {
  1689.             shade_table[Machine->pens[color_start + i]]=Machine->pens[color_start + i];
  1690.         }
  1691.     }
  1692.     else
  1693.     {
  1694.         if(sys16_MaxShadowColors != 0)
  1695.         {
  1696.             size=Machine->drv->total_colors/2;
  1697.             for(i=0;i<size;i++)
  1698.             {
  1699.                 shade_table[Machine->pens[i]]=Machine->pens[size + i];
  1700.                 shade_table[Machine->pens[size+i]]=Machine->pens[size + i];
  1701.             }
  1702.         }
  1703.         else
  1704.         {
  1705.             size=Machine->drv->total_colors;
  1706.             for(i=0;i<size;i++)
  1707.             {
  1708.                 shade_table[Machine->pens[i]]=Machine->pens[i];
  1709.             }
  1710.         }
  1711.     }
  1712. }
  1713. #else
  1714. #define build_shadow_table()
  1715. #endif
  1716.  
  1717. void sys16_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh){
  1718.     if( sys16_update_proc ) sys16_update_proc();
  1719.     update_page();
  1720.  
  1721.     // from sys16 emu (Not sure if this is the best place for this?)
  1722.     {
  1723.         static int freeze_counter=0;
  1724.         if (!sys16_refreshenable)
  1725.         {
  1726.             freeze_counter=4;
  1727.             sys16_freezepalette=1;
  1728.         }
  1729.         if (freeze_counter)
  1730.         {
  1731.             if( sys16_clear_screen)
  1732.                 fillbitmap(bitmap,palette_transparent_color,&Machine->drv->visible_area);
  1733.             freeze_counter--;
  1734.             return;
  1735.         }
  1736.         else if(sys16_freezepalette)
  1737.         {
  1738.             sys16_refresh_palette();
  1739.             sys16_freezepalette=0;
  1740.         }
  1741.     }
  1742.  
  1743.     if( sys16_refreshenable ){
  1744.  
  1745.         if(sys18_splittab_bg_x)
  1746.         {
  1747.             if((sys16_bg_scrollx&0xff00)  != sys16_rowscroll_scroll)
  1748.             {
  1749.                 tilemap_set_scroll_rows( background , 1 );
  1750.                 tilemap_set_scrollx( background, 0, -320-sys16_bg_scrollx+sys16_bgxoffset );
  1751.             }
  1752.             else
  1753.             {
  1754.                 int offset, scroll,i;
  1755.  
  1756.                 tilemap_set_scroll_rows( background , 64 );
  1757.                 offset = 32+((sys16_bg_scrolly&0x1f8) >> 3);
  1758.  
  1759.                 for(i=0;i<29;i++)
  1760.                 {
  1761.                     scroll = READ_WORD(&sys18_splittab_bg_x[i*2]);
  1762.                     tilemap_set_scrollx( background , (i+offset)&0x3f, -320-(scroll&0x3ff)+sys16_bgxoffset );
  1763.                 }
  1764.             }
  1765.         }
  1766.         else
  1767.         {
  1768.             tilemap_set_scrollx( background, 0, -320-sys16_bg_scrollx+sys16_bgxoffset );
  1769.         }
  1770.  
  1771.         if(sys18_splittab_bg_y)
  1772.         {
  1773.             if((sys16_bg_scrolly&0xff00)  != sys16_rowscroll_scroll)
  1774.             {
  1775.                 tilemap_set_scroll_cols( background , 1 );
  1776.                 tilemap_set_scrolly( background, 0, -256+sys16_bg_scrolly );
  1777.             }
  1778.             else
  1779.             {
  1780.                 int offset, scroll,i;
  1781.  
  1782.                 tilemap_set_scroll_cols( background , 128 );
  1783.                 offset = 127-((sys16_bg_scrollx&0x3f8) >> 3)-40+2;
  1784.  
  1785.                 for(i=0;i<41;i++)
  1786.                 {
  1787.                     scroll = READ_WORD(&sys18_splittab_bg_y[(i+24)&0xfffe]);
  1788.                     tilemap_set_scrolly( background , (i+offset)&0x7f, -256+(scroll&0x3ff) );
  1789.                 }
  1790.             }
  1791.         }
  1792.         else
  1793.         {
  1794.             tilemap_set_scrolly( background, 0, -256+sys16_bg_scrolly );
  1795.         }
  1796.  
  1797.         if(sys18_splittab_fg_x)
  1798.         {
  1799.             if((sys16_fg_scrollx&0xff00)  != sys16_rowscroll_scroll)
  1800.             {
  1801.                 tilemap_set_scroll_rows( foreground , 1 );
  1802.                 tilemap_set_scrollx( foreground, 0, -320-sys16_fg_scrollx+sys16_fgxoffset );
  1803.             }
  1804.             else
  1805.             {
  1806.                 int offset, scroll,i;
  1807.  
  1808.                 tilemap_set_scroll_rows( foreground , 64 );
  1809.                 offset = 32+((sys16_fg_scrolly&0x1f8) >> 3);
  1810.  
  1811.                 for(i=0;i<29;i++)
  1812.                 {
  1813.                     scroll = READ_WORD(&sys18_splittab_fg_x[i*2]);
  1814.  
  1815.  
  1816.                     tilemap_set_scrollx( foreground , (i+offset)&0x3f, -320-(scroll&0x3ff)+sys16_fgxoffset );
  1817.                 }
  1818.             }
  1819.         }
  1820.         else
  1821.         {
  1822.             tilemap_set_scrollx( foreground, 0, -320-sys16_fg_scrollx+sys16_fgxoffset );
  1823.         }
  1824.  
  1825.         if(sys18_splittab_fg_y)
  1826.         {
  1827.             if((sys16_fg_scrolly&0xff00)  != sys16_rowscroll_scroll)
  1828.             {
  1829.                 tilemap_set_scroll_cols( foreground , 1 );
  1830.                 tilemap_set_scrolly( foreground, 0, -256+sys16_fg_scrolly );
  1831.             }
  1832.             else
  1833.             {
  1834.                 int offset, scroll,i;
  1835.  
  1836.                 tilemap_set_scroll_cols( foreground , 128 );
  1837.                 offset = 127-((sys16_fg_scrollx&0x3f8) >> 3)-40+2;
  1838.  
  1839.                 for(i=0;i<41;i++)
  1840.                 {
  1841.                     scroll = READ_WORD(&sys18_splittab_fg_y[(i+24)&0xfffe]);
  1842.                     tilemap_set_scrolly( foreground , (i+offset)&0x7f, -256+(scroll&0x3ff) );
  1843.                 }
  1844.             }
  1845.         }
  1846.         else
  1847.         {
  1848.             tilemap_set_scrolly( foreground, 0, -256+sys16_fg_scrolly );
  1849.         }
  1850.  
  1851.         if(sys16_quartet_title_kludge)
  1852.         {
  1853.             int top,bottom,left,right;
  1854.             int top2,bottom2,left2,right2;
  1855.             struct rectangle clip;
  1856.  
  1857.             left = background->clip_left;
  1858.             right = background->clip_right;
  1859.             top = background->clip_top;
  1860.             bottom = background->clip_bottom;
  1861.  
  1862.             left2 = foreground->clip_left;
  1863.             right2 = foreground->clip_right;
  1864.             top2 = foreground->clip_top;
  1865.             bottom2 = foreground->clip_bottom;
  1866.  
  1867.             clip.min_x=0;
  1868.             clip.min_y=0;
  1869.             clip.max_x=1024;
  1870.             clip.max_y=512;
  1871.  
  1872.             tilemap_set_clip( background, &clip );
  1873.             tilemap_set_clip( foreground, &clip );
  1874.  
  1875.             tilemap_update(  ALL_TILEMAPS  );
  1876.  
  1877.             background->clip_left = left;
  1878.             background->clip_right = right;
  1879.             background->clip_top = top;
  1880.             background->clip_bottom = bottom;
  1881.  
  1882.             foreground->clip_left = left2;
  1883.             foreground->clip_right = right2;
  1884.             foreground->clip_top = top2;
  1885.             foreground->clip_bottom = bottom2;
  1886.  
  1887.         }
  1888.         else
  1889.             tilemap_update(  ALL_TILEMAPS  );
  1890.  
  1891.  
  1892.         get_sprite_info();
  1893.  
  1894.         palette_init_used_colors();
  1895.         mark_sprite_colors(); // custom; normally this would be handled by the sprite manager
  1896.         sprite_update();
  1897.  
  1898.         if( palette_recalc() ) tilemap_mark_all_pixels_dirty( ALL_TILEMAPS );
  1899.         build_shadow_table();
  1900.         tilemap_render(  ALL_TILEMAPS  );
  1901.  
  1902.         if(!sys16_quartet_title_kludge)
  1903.         {
  1904.             tilemap_draw( bitmap, background, TILEMAP_IGNORE_TRANSPARENCY );
  1905.             if(sys16_bg_priority_mode) tilemap_draw( bitmap, background, TILEMAP_IGNORE_TRANSPARENCY | 1 );
  1906.         }
  1907.         else
  1908.             draw_quartet_title_screen( bitmap, 0 );
  1909.  
  1910.         sprite_draw(sprite_list,3); // needed for Aurail
  1911.         if(sys16_bg_priority_mode==2) tilemap_draw( bitmap, background, 1 );        // body slam (& wrestwar??)
  1912.         sprite_draw(sprite_list,2);
  1913.         if(sys16_bg_priority_mode==1) tilemap_draw( bitmap, background, 1 );        // alien syndrome / aurail
  1914.  
  1915.         if(!sys16_quartet_title_kludge)
  1916.         {
  1917.             tilemap_draw( bitmap, foreground, 0 );
  1918.             sprite_draw(sprite_list,1);
  1919.             tilemap_draw( bitmap, foreground, 1 );
  1920.         }
  1921.         else
  1922.         {
  1923.             draw_quartet_title_screen( bitmap, 1 );
  1924.             sprite_draw(sprite_list,1);
  1925.         }
  1926.  
  1927.         if(sys16_textlayer_lo_max!=0) tilemap_draw( bitmap, text_layer, 1 ); // needed for Body Slam
  1928.         sprite_draw(sprite_list,0);
  1929.         tilemap_draw( bitmap, text_layer, 0 );
  1930.     }
  1931. #ifdef SYS16_DEBUG
  1932.     dump_tilemap();
  1933. #endif
  1934. }
  1935.  
  1936. void sys18_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh){
  1937.     int i;
  1938.     if( sys16_update_proc ) sys16_update_proc();
  1939.     update_page();
  1940.  
  1941.     // from sys16 emu (Not sure if this is the best place for this?)
  1942.     {
  1943.         static int freeze_counter=0;
  1944.         if (!sys16_refreshenable)
  1945.         {
  1946.             freeze_counter=4;
  1947.             sys16_freezepalette=1;
  1948.         }
  1949.         if (freeze_counter)
  1950.         {
  1951. //            if( sys16_clear_screen)
  1952. //                fillbitmap(bitmap,palette_transparent_color,&Machine->drv->visible_area);
  1953.             freeze_counter--;
  1954.             return;
  1955.         }
  1956.         else if(sys16_freezepalette)
  1957.         {
  1958.             sys16_refresh_palette();
  1959.             sys16_freezepalette=0;
  1960.         }
  1961.     }
  1962.  
  1963.     if( sys16_refreshenable ){
  1964.  
  1965.         if(sys18_splittab_bg_x)
  1966.         {
  1967.             int offset,offset2, scroll,scroll2,orig_scroll;
  1968.  
  1969.             offset = 32+((sys16_bg_scrolly&0x1f8) >> 3);
  1970.             offset2 = 32+((sys16_bg2_scrolly&0x1f8) >> 3);
  1971.  
  1972.             for(i=0;i<29;i++)
  1973.             {
  1974.                 orig_scroll = scroll2 = scroll = READ_WORD(&sys18_splittab_bg_x[i*2]);
  1975.  
  1976.                 if((sys16_bg_scrollx &0xff00) != 0x8000)
  1977.                     scroll = sys16_bg_scrollx;
  1978.  
  1979.                 if((sys16_bg2_scrollx &0xff00) != 0x8000)
  1980.                     scroll2 = sys16_bg2_scrollx;
  1981.  
  1982.                 if(orig_scroll&0x8000)
  1983.                 {
  1984.                     tilemap_set_scrollx( background , (i+offset)&0x3f, TILE_LINE_DISABLED );
  1985.                     tilemap_set_scrollx( background2, (i+offset2)&0x3f, -320-(scroll2&0x3ff)+sys16_bgxoffset );
  1986.                 }
  1987.                 else
  1988.                 {
  1989.                     tilemap_set_scrollx( background , (i+offset)&0x3f, -320-(scroll&0x3ff)+sys16_bgxoffset );
  1990.                     tilemap_set_scrollx( background2 , (i+offset2)&0x3f, TILE_LINE_DISABLED );
  1991.                 }
  1992.             }
  1993.         }
  1994.         else
  1995.         {
  1996.             tilemap_set_scrollx( background , 0, -320-(sys16_bg_scrollx&0x3ff)+sys16_bgxoffset );
  1997.             tilemap_set_scrollx( background2, 0, -320-(sys16_bg2_scrollx&0x3ff)+sys16_bgxoffset );
  1998.         }
  1999.  
  2000.         tilemap_set_scrolly( background , 0, -256+sys16_bg_scrolly );
  2001.         tilemap_set_scrolly( background2, 0, -256+sys16_bg2_scrolly );
  2002.  
  2003.         if(sys18_splittab_fg_x)
  2004.         {
  2005.             int offset,offset2, scroll,scroll2,orig_scroll;
  2006.  
  2007.             offset = 32+((sys16_fg_scrolly&0x1f8) >> 3);
  2008.             offset2 = 32+((sys16_fg2_scrolly&0x1f8) >> 3);
  2009.  
  2010.             for(i=0;i<29;i++)
  2011.             {
  2012.                 orig_scroll = scroll2 = scroll = READ_WORD(&sys18_splittab_fg_x[i*2]);
  2013.  
  2014.                 if((sys16_fg_scrollx &0xff00) != 0x8000)
  2015.                     scroll = sys16_fg_scrollx;
  2016.  
  2017.                 if((sys16_fg2_scrollx &0xff00) != 0x8000)
  2018.                     scroll2 = sys16_fg2_scrollx;
  2019.  
  2020.                 if(orig_scroll&0x8000)
  2021.                 {
  2022.                     tilemap_set_scrollx( foreground , (i+offset)&0x3f, TILE_LINE_DISABLED );
  2023.                     tilemap_set_scrollx( foreground2, (i+offset2)&0x3f, -320-(scroll2&0x3ff)+sys16_fgxoffset );
  2024.                 }
  2025.                 else
  2026.                 {
  2027.                     tilemap_set_scrollx( foreground , (i+offset)&0x3f, -320-(scroll&0x3ff)+sys16_fgxoffset );
  2028.                     tilemap_set_scrollx( foreground2 , (i+offset2)&0x3f, TILE_LINE_DISABLED );
  2029.                 }
  2030.             }
  2031.         }
  2032.         else
  2033.         {
  2034.             tilemap_set_scrollx( foreground , 0, -320-(sys16_fg_scrollx&0x3ff)+sys16_fgxoffset );
  2035.             tilemap_set_scrollx( foreground2, 0, -320-(sys16_fg2_scrollx&0x3ff)+sys16_fgxoffset );
  2036.         }
  2037.  
  2038.  
  2039.         tilemap_set_scrolly( foreground , 0, -256+sys16_fg_scrolly );
  2040.         tilemap_set_scrolly( foreground2, 0, -256+sys16_fg2_scrolly );
  2041.  
  2042.         tilemap_set_enable( background2, sys18_bg2_active );
  2043.         tilemap_set_enable( foreground2, sys18_fg2_active );
  2044.  
  2045.         tilemap_update(  ALL_TILEMAPS  );
  2046.         get_sprite_info();
  2047.  
  2048.         palette_init_used_colors();
  2049.         mark_sprite_colors(); // custom; normally this would be handled by the sprite manager
  2050.         sprite_update();
  2051.  
  2052.         if( palette_recalc() ) tilemap_mark_all_pixels_dirty( ALL_TILEMAPS );
  2053.         build_shadow_table();
  2054.         tilemap_render(  ALL_TILEMAPS  );
  2055.  
  2056.         if(sys18_bg2_active)
  2057.             tilemap_draw( bitmap, background2, 0 );
  2058.         else
  2059.             fillbitmap(bitmap,palette_transparent_color,&Machine->drv->visible_area);
  2060.  
  2061.         tilemap_draw( bitmap, background, TILEMAP_IGNORE_TRANSPARENCY );
  2062.         tilemap_draw( bitmap, background, TILEMAP_IGNORE_TRANSPARENCY | 1 );    //??
  2063.         tilemap_draw( bitmap, background, TILEMAP_IGNORE_TRANSPARENCY | 2 );    //??
  2064.  
  2065.         sprite_draw(sprite_list,3);
  2066.         tilemap_draw( bitmap, background, 1 );
  2067.         sprite_draw(sprite_list,2);
  2068.         tilemap_draw( bitmap, background, 2 );
  2069.  
  2070.         if(sys18_fg2_active) tilemap_draw( bitmap, foreground2, 0 );
  2071.         tilemap_draw( bitmap, foreground, 0 );
  2072.         sprite_draw(sprite_list,1);
  2073.         if(sys18_fg2_active) tilemap_draw( bitmap, foreground2, 1 );
  2074.         tilemap_draw( bitmap, foreground, 1 );
  2075.  
  2076.         tilemap_draw( bitmap, text_layer, 1 );
  2077.         sprite_draw(sprite_list,0);
  2078.         tilemap_draw( bitmap, text_layer, 0 );
  2079.     }
  2080. }
  2081.  
  2082. extern int gr_bitmap_width;
  2083.  
  2084. static void gr_colors(void)
  2085. {
  2086.     int i;
  2087.     UINT16 ver_data;
  2088.     int colorflip;
  2089.     UINT8 *data_ver=gr_ver;
  2090.  
  2091.     for(i=0;i<224;i++)
  2092.     {
  2093.         ver_data=READ_WORD(data_ver);
  2094.         palette_used_colors[(READ_WORD(&gr_pal[(ver_data<<1)&0x1fe])&0xff) + gr_palette] = PALETTE_COLOR_USED;
  2095.  
  2096.         if(!((ver_data & 0x500) == 0x100 || (ver_data & 0x300) == 0x200))
  2097.         {
  2098.             ver_data=ver_data & 0x00ff;
  2099.             colorflip = (READ_WORD(&gr_flip[ver_data<<1]) >> 3) & 1;
  2100.  
  2101.             palette_used_colors[ gr_colorflip[colorflip][0] + gr_palette_default ] = PALETTE_COLOR_USED;
  2102.             palette_used_colors[ gr_colorflip[colorflip][1] + gr_palette_default ] = PALETTE_COLOR_USED;
  2103.             palette_used_colors[ gr_colorflip[colorflip][2] + gr_palette_default ] = PALETTE_COLOR_USED;
  2104.             palette_used_colors[ gr_colorflip[colorflip][3] + gr_palette_default ] = PALETTE_COLOR_USED;
  2105.         }
  2106.         data_ver+=2;
  2107.     }
  2108. }
  2109.  
  2110. static void render_gr(struct osd_bitmap *bitmap,int priority)
  2111. {
  2112.     int i,j;
  2113.     UINT8 *data = memory_region(REGION_GFX3);
  2114.     UINT8 *source;
  2115.     UINT8 *line;
  2116.     UINT16 *line16;
  2117.     UINT32 *line32;
  2118.     UINT8 *data_ver=gr_ver;
  2119.     UINT32 ver_data,hor_pos;
  2120.     UINT16 colors[5];
  2121. //    UINT8 colors[5];
  2122.     UINT32 fastfill;
  2123.     int colorflip;
  2124.     int yflip=0,ypos;
  2125.     int dx=1,xoff=0;
  2126.  
  2127.     UINT16 *paldata1 = Machine->gfx[0]->colortable + gr_palette;
  2128.     UINT16 *paldata2 = Machine->gfx[0]->colortable + gr_palette_default;
  2129.  
  2130.     priority=priority << 10;
  2131.  
  2132.     if (Machine->scrbitmap->depth == 16) /* 16 bit */
  2133.     {
  2134.         if( Machine->orientation & ORIENTATION_SWAP_XY )
  2135.         {
  2136.             if( Machine->orientation & ORIENTATION_FLIP_Y ){
  2137.                 dx=-1;
  2138.                 xoff=319;
  2139.             }
  2140.             if( Machine->orientation & ORIENTATION_FLIP_X ){
  2141.                 yflip=1;
  2142.             }
  2143.  
  2144.             for(i=0;i<224;i++)
  2145.             {
  2146.                 if(yflip) ypos=223-i;
  2147.                 else ypos=i;
  2148.                 ver_data=READ_WORD(data_ver);
  2149.                 if((ver_data & 0x400) == priority)
  2150.                 {
  2151.                     colors[0] = paldata1[ READ_WORD(&gr_pal[(ver_data<<1)&0x1fe])&0xff ];
  2152.  
  2153.                     if((ver_data & 0x500) == 0x100 || (ver_data & 0x300) == 0x200)
  2154.                     {
  2155.                         // fill line
  2156.                         for(j=0;j<320;j++)
  2157.                         {
  2158.                             line16=(UINT16 *)bitmap->line[j]+ypos;
  2159.                             *line16=colors[0];
  2160.                         }
  2161.                     }
  2162.                     else
  2163.                     {
  2164.                         // copy line
  2165.                         ver_data=ver_data & 0x00ff;
  2166.                         colorflip = (READ_WORD(&gr_flip[ver_data<<1]) >> 3) & 1;
  2167.  
  2168.                         colors[1] = paldata2[ gr_colorflip[colorflip][0] ];
  2169.                         colors[2] = paldata2[ gr_colorflip[colorflip][1] ];
  2170.                         colors[3] = paldata2[ gr_colorflip[colorflip][2] ];
  2171.                         colors[4] = paldata2[ gr_colorflip[colorflip][3] ];
  2172.  
  2173.                         hor_pos = (READ_WORD(&gr_hor[ver_data<<1]) );
  2174.                         ver_data = ver_data << gr_bitmap_width;
  2175.  
  2176.                         if(hor_pos & 0xf000)
  2177.                         {
  2178.                             // reverse
  2179.                             hor_pos=((0-((hor_pos&0x7ff)^7))+0x9f8)&0x3ff;
  2180.                         }
  2181.                         else
  2182.                         {
  2183.                             // normal
  2184.                             hor_pos=(hor_pos+0x200) & 0x3ff;
  2185.                         }
  2186.  
  2187.                         source = data + hor_pos + ver_data + 18 + 8;
  2188.  
  2189.                         for(j=0;j<320;j++)
  2190.                         {
  2191.                             line16=(UINT16 *)bitmap->line[xoff+j*dx]+ypos;
  2192.                             *line16 = colors[*source++];
  2193.                         }
  2194.                     }
  2195.                 }
  2196.                 data_ver+=2;
  2197.             }
  2198.         }
  2199.         else
  2200.         {
  2201.             if( Machine->orientation & ORIENTATION_FLIP_X ){
  2202.                 dx=-1;
  2203.                 xoff=319;
  2204.             }
  2205.             if( Machine->orientation & ORIENTATION_FLIP_Y ){
  2206.                 yflip=1;
  2207.             }
  2208.  
  2209.             for(i=0;i<224;i++)
  2210.             {
  2211.                 if(yflip) ypos=223-i;
  2212.                 else ypos=i;
  2213.                 ver_data=READ_WORD(data_ver);
  2214.                 if((ver_data & 0x400) == priority)
  2215.                 {
  2216.                     colors[0] = paldata1[ READ_WORD(&gr_pal[(ver_data<<1)&0x1fe])&0xff ];
  2217.  
  2218.                     if((ver_data & 0x500) == 0x100 || (ver_data & 0x300) == 0x200)
  2219.                     {
  2220.                         line16=(UINT16 *)bitmap->line[ypos];
  2221.                         for(j=0;j<320;j++)
  2222.                         {
  2223.                             *line16++=colors[0];
  2224.                         }
  2225.                     }
  2226.                     else
  2227.                     {
  2228.                         // copy line
  2229.                         line16 = (UINT16 *)bitmap->line[ypos]+xoff;
  2230.                         ver_data=ver_data & 0x00ff;
  2231.                         colorflip = (READ_WORD(&gr_flip[ver_data<<1]) >> 3) & 1;
  2232.  
  2233.                         colors[1] = paldata2[ gr_colorflip[colorflip][0] ];
  2234.                         colors[2] = paldata2[ gr_colorflip[colorflip][1] ];
  2235.                         colors[3] = paldata2[ gr_colorflip[colorflip][2] ];
  2236.                         colors[4] = paldata2[ gr_colorflip[colorflip][3] ];
  2237.  
  2238.                         hor_pos = (READ_WORD(&gr_hor[ver_data<<1]) );
  2239.                         ver_data = ver_data << gr_bitmap_width;
  2240.  
  2241.                         if(hor_pos & 0xf000)
  2242.                         {
  2243.                             // reverse
  2244.                             hor_pos=((0-((hor_pos&0x7ff)^7))+0x9f8)&0x3ff;
  2245.                         }
  2246.                         else
  2247.                         {
  2248.                             // normal
  2249.                             hor_pos=(hor_pos+0x200) & 0x3ff;
  2250.                         }
  2251.  
  2252.                         source = data + hor_pos + ver_data + 18 + 8;
  2253.  
  2254.                         for(j=0;j<320;j++)
  2255.                         {
  2256.                             *line16 = colors[*source++];
  2257.                             line16+=dx;
  2258.                         }
  2259.                     }
  2260.                 }
  2261.                 data_ver+=2;
  2262.             }
  2263.         }
  2264.     }
  2265.     else /* 8 bit */
  2266.     {
  2267.         if( Machine->orientation & ORIENTATION_SWAP_XY )
  2268.         {
  2269.             if( Machine->orientation & ORIENTATION_FLIP_Y ){
  2270.                 dx=-1;
  2271.                 xoff=319;
  2272.             }
  2273.             if( Machine->orientation & ORIENTATION_FLIP_X ){
  2274.                 yflip=1;
  2275.             }
  2276.  
  2277.             for(i=0;i<224;i++)
  2278.             {
  2279.                 if(yflip) ypos=223-i;
  2280.                 else ypos=i;
  2281.                 ver_data=READ_WORD(data_ver);
  2282.                 if((ver_data & 0x400) == priority)
  2283.                 {
  2284.                     colors[0] = paldata1[ READ_WORD(&gr_pal[(ver_data<<1)&0x1fe])&0xff ];
  2285.  
  2286.                     if((ver_data & 0x500) == 0x100 || (ver_data & 0x300) == 0x200)
  2287.                     {
  2288.                         // fill line
  2289.                         for(j=0;j<320;j++)
  2290.                         {
  2291.                             bitmap->line[j][ypos]=colors[0];
  2292.                         }
  2293.                     }
  2294.                     else
  2295.                     {
  2296.                         // copy line
  2297.                         ver_data=ver_data & 0x00ff;
  2298.                         colorflip = (READ_WORD(&gr_flip[ver_data<<1]) >> 3) & 1;
  2299.  
  2300.                         colors[1] = paldata2[ gr_colorflip[colorflip][0] ];
  2301.                         colors[2] = paldata2[ gr_colorflip[colorflip][1] ];
  2302.                         colors[3] = paldata2[ gr_colorflip[colorflip][2] ];
  2303.                         colors[4] = paldata2[ gr_colorflip[colorflip][3] ];
  2304.  
  2305.                         hor_pos = (READ_WORD(&gr_hor[ver_data<<1]) );
  2306.                         ver_data = ver_data << gr_bitmap_width;
  2307.  
  2308.                         if(hor_pos & 0xf000)
  2309.                         {
  2310.                             // reverse
  2311.                             hor_pos=((0-((hor_pos&0x7ff)^7))+0x9f8)&0x3ff;
  2312.                         }
  2313.                         else
  2314.                         {
  2315.                             // normal
  2316.                             hor_pos=(hor_pos+0x200) & 0x3ff;
  2317.                         }
  2318.  
  2319.                         source = data + hor_pos + ver_data + 18 + 8;
  2320.  
  2321.                         for(j=0;j<320;j++)
  2322.                         {
  2323.                             bitmap->line[xoff+j*dx][ypos] = colors[*source++];
  2324.                         }
  2325.                     }
  2326.                 }
  2327.                 data_ver+=2;
  2328.             }
  2329.         }
  2330.         else
  2331.         {
  2332.             if( Machine->orientation & ORIENTATION_FLIP_X ){
  2333.                 dx=-1;
  2334.                 xoff=319;
  2335.             }
  2336.             if( Machine->orientation & ORIENTATION_FLIP_Y ){
  2337.                 yflip=1;
  2338.             }
  2339.  
  2340.             for(i=0;i<224;i++)
  2341.             {
  2342.                 if(yflip) ypos=223-i;
  2343.                 else ypos=i;
  2344.                 ver_data=READ_WORD(data_ver);
  2345.                 if((ver_data & 0x400) == priority)
  2346.                 {
  2347.                     colors[0] = paldata1[ READ_WORD(&gr_pal[(ver_data<<1)&0x1fe])&0xff ];
  2348.  
  2349.                     if((ver_data & 0x500) == 0x100 || (ver_data & 0x300) == 0x200)
  2350.                     {
  2351.                         // fill line
  2352.                         line32 = (UINT32 *)bitmap->line[ypos];
  2353.                         fastfill = colors[0] + (colors[0] << 8) + (colors[0] << 16) + (colors[0] << 24);
  2354.                         for(j=0;j<320;j+=4)
  2355.                         {
  2356.                             *line32++ = fastfill;
  2357.                         }
  2358.                     }
  2359.                     else
  2360.                     {
  2361.                         // copy line
  2362.                         line = bitmap->line[ypos]+xoff;
  2363.                         ver_data=ver_data & 0x00ff;
  2364.                         colorflip = (READ_WORD(&gr_flip[ver_data<<1]) >> 3) & 1;
  2365.  
  2366.                         colors[1] = paldata2[ gr_colorflip[colorflip][0] ];
  2367.                         colors[2] = paldata2[ gr_colorflip[colorflip][1] ];
  2368.                         colors[3] = paldata2[ gr_colorflip[colorflip][2] ];
  2369.                         colors[4] = paldata2[ gr_colorflip[colorflip][3] ];
  2370.  
  2371.                         hor_pos = (READ_WORD(&gr_hor[ver_data<<1]) );
  2372.                         ver_data = ver_data << gr_bitmap_width;
  2373.  
  2374.                         if(hor_pos & 0xf000)
  2375.                         {
  2376.                             // reverse
  2377.                             hor_pos=((0-((hor_pos&0x7ff)^7))+0x9f8)&0x3ff;
  2378.                         }
  2379.                         else
  2380.                         {
  2381.                             // normal
  2382.                             hor_pos=(hor_pos+0x200) & 0x3ff;
  2383.                         }
  2384.  
  2385.                         source = data + hor_pos + ver_data + 18 + 8;
  2386.  
  2387.                         for(j=0;j<320;j++)
  2388.                         {
  2389.                             *line = colors[*source++];
  2390.                             line+=dx;
  2391.                         }
  2392.                     }
  2393.                 }
  2394.                 data_ver+=2;
  2395.             }
  2396.         }
  2397.     }
  2398. }
  2399.  
  2400.  
  2401.  
  2402.  
  2403. // Refresh for hang-on, etc.
  2404. void sys16_ho_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh){
  2405.     if( sys16_update_proc ) sys16_update_proc();
  2406.     update_page();
  2407.  
  2408.     // from sys16 emu (Not sure if this is the best place for this?)
  2409.     {
  2410.         static int freeze_counter=0;
  2411.         if (!sys16_refreshenable)
  2412.         {
  2413.             freeze_counter=4;
  2414.             sys16_freezepalette=1;
  2415.         }
  2416.         if (freeze_counter)
  2417.         {
  2418.             freeze_counter--;
  2419.             return;
  2420.         }
  2421.         else if(sys16_freezepalette)
  2422.         {
  2423.             sys16_refresh_palette();
  2424.             sys16_freezepalette=0;
  2425.         }
  2426.     }
  2427.  
  2428.     if( sys16_refreshenable ){
  2429.  
  2430.         tilemap_set_scrollx( background, 0, -320-sys16_bg_scrollx+sys16_bgxoffset );
  2431.         tilemap_set_scrollx( foreground, 0, -320-sys16_fg_scrollx+sys16_fgxoffset );
  2432.  
  2433.         tilemap_set_scrolly( background, 0, -256+sys16_bg_scrolly );
  2434.         tilemap_set_scrolly( foreground, 0, -256+sys16_fg_scrolly );
  2435.  
  2436.         tilemap_update(  ALL_TILEMAPS  );
  2437.         get_sprite_info();
  2438.  
  2439.         palette_init_used_colors();
  2440.         mark_sprite_colors(); // custom; normally this would be handled by the sprite manager
  2441.         sprite_update();
  2442.         gr_colors();
  2443.  
  2444.         if( palette_recalc() ) tilemap_mark_all_pixels_dirty( ALL_TILEMAPS );
  2445.         build_shadow_table();
  2446.         tilemap_render(  ALL_TILEMAPS  );
  2447.  
  2448.         render_gr(bitmap,0);
  2449.  
  2450.         tilemap_draw( bitmap, background, 0 );
  2451.         tilemap_draw( bitmap, foreground, 0 );
  2452.  
  2453.         render_gr(bitmap,1);
  2454.  
  2455.         sprite_draw(sprite_list,0);
  2456.         tilemap_draw( bitmap, text_layer, 0 );
  2457.  
  2458.     }
  2459.  
  2460. #ifdef SYS16_DEBUG
  2461.     dump_tilemap();
  2462. #endif
  2463. }
  2464.  
  2465.  
  2466. static void grv2_colors(void)
  2467. {
  2468.     int i;
  2469.     UINT16 ver_data;
  2470.     int colorflip,colorflip_info;
  2471.     UINT8 *data_ver=gr_ver;
  2472.  
  2473.     for(i=0;i<224;i++)
  2474.     {
  2475.         ver_data=READ_WORD(data_ver);
  2476.  
  2477.         if(!(ver_data & 0x800))
  2478.         {
  2479.             ver_data=ver_data & 0x01ff;
  2480.             colorflip_info = READ_WORD(&gr_flip[ver_data<<1]);
  2481.  
  2482.             palette_used_colors[ (((colorflip_info >> 8) & 0x1f) + 0x20) + gr_palette_default] = PALETTE_COLOR_USED;
  2483.  
  2484.             colorflip = (colorflip_info >> 3) & 1;
  2485.  
  2486.             palette_used_colors[ gr_colorflip[colorflip][0] + gr_palette_default ] = PALETTE_COLOR_USED;
  2487.             palette_used_colors[ gr_colorflip[colorflip][1] + gr_palette_default ] = PALETTE_COLOR_USED;
  2488.             palette_used_colors[ gr_colorflip[colorflip][2] + gr_palette_default ] = PALETTE_COLOR_USED;
  2489.         }
  2490.         else
  2491.         {
  2492.             palette_used_colors[(ver_data&0x3f) + gr_palette] = PALETTE_COLOR_USED;
  2493.         }
  2494.         data_ver+=2;
  2495.     }
  2496. }
  2497.  
  2498. static void render_grv2(struct osd_bitmap *bitmap,int priority)
  2499. {
  2500.     int i,j;
  2501.     UINT8 *data = memory_region(REGION_GFX3);
  2502.     UINT8 *source,*source2,*temp;
  2503.     UINT8 *line;
  2504.     UINT16 *line16;
  2505.     UINT32 *line32;
  2506.     UINT8 *data_ver=gr_ver;
  2507.     UINT32 ver_data,hor_pos,hor_pos2;
  2508.     UINT16 colors[5];
  2509.     UINT32 fastfill;
  2510.     int colorflip,colorflip_info;
  2511.     int yflip=0,ypos;
  2512.     int dx=1,xoff=0;
  2513.  
  2514.     int second_road = READ_WORD(gr_second_road);
  2515.  
  2516.     UINT16 *paldata1 = Machine->gfx[0]->colortable + gr_palette;
  2517.     UINT16 *paldata2 = Machine->gfx[0]->colortable + gr_palette_default;
  2518.  
  2519.     priority=priority << 11;
  2520.  
  2521.     if (Machine->scrbitmap->depth == 16) /* 16 bit */
  2522.     {
  2523.         if( Machine->orientation & ORIENTATION_SWAP_XY )
  2524.         {
  2525.             if( Machine->orientation & ORIENTATION_FLIP_Y ){
  2526.                 dx=-1;
  2527.                 xoff=319;
  2528.             }
  2529.             if( Machine->orientation & ORIENTATION_FLIP_X ){
  2530.                 yflip=1;
  2531.             }
  2532.  
  2533.             for(i=0;i<224;i++)
  2534.             {
  2535.                 if(yflip) ypos=223-i;
  2536.                 else ypos=i;
  2537.                 ver_data=READ_WORD(data_ver);
  2538.                 if((ver_data & 0x800) == priority)
  2539.                 {
  2540.  
  2541.                     if(ver_data & 0x800)
  2542.                     {
  2543.                         colors[0] = paldata1[ ver_data&0x3f ];
  2544.                         // fill line
  2545.                         for(j=0;j<320;j++)
  2546.                         {
  2547.                             line16=(UINT16 *)bitmap->line[j]+ypos;
  2548.                             *line16=colors[0];
  2549.                         }
  2550.                     }
  2551.                     else
  2552.                     {
  2553.                         // copy line
  2554.                         ver_data=ver_data & 0x01ff;        //???
  2555.                         colorflip_info = READ_WORD(&gr_flip[ver_data<<1]);
  2556.  
  2557.                         colors[0] = paldata2[ ((colorflip_info >> 8) & 0x1f) + 0x20 ];        //??
  2558.  
  2559.                         colorflip = (colorflip_info >> 3) & 1;
  2560.  
  2561.                         colors[1] = paldata2[ gr_colorflip[colorflip][0] ];
  2562.                         colors[2] = paldata2[ gr_colorflip[colorflip][1] ];
  2563.                         colors[3] = paldata2[ gr_colorflip[colorflip][2] ];
  2564.  
  2565.                         hor_pos = (READ_WORD(&gr_hor[ver_data<<1]) );
  2566.                         hor_pos2= (READ_WORD(&gr_hor[(ver_data<<1)+0x400]) );
  2567.  
  2568.                         ver_data=ver_data>>1;
  2569.                         if( ver_data != 0 )
  2570.                         {
  2571.                             ver_data = (ver_data-1) << gr_bitmap_width;
  2572.                         }
  2573.  
  2574.                         source  = data + ((hor_pos +0x200) & 0x7ff) + 768 + ver_data + 8;
  2575.                         source2 = data + ((hor_pos2+0x200) & 0x7ff) + 768 + ver_data + 8;
  2576.  
  2577.                         switch(second_road)
  2578.                         {
  2579.                             case 0:    source2=source;    break;
  2580.                             case 2:    temp=source;source=source2;source2=temp; break;
  2581.                             case 3:    source=source2;    break;
  2582.                         }
  2583.  
  2584.                         source2++;
  2585.  
  2586.                         for(j=0;j<320;j++)
  2587.                         {
  2588.                             line16=(UINT16 *)bitmap->line[xoff+j*dx]+ypos;
  2589.                             if(*source2 <= *source)
  2590.                                 *line16 = colors[*source];
  2591.                             else
  2592.                                 *line16 = colors[*source2];
  2593.                             source++;
  2594.                             source2++;
  2595.                         }
  2596.                     }
  2597.                 }
  2598.                 data_ver+=2;
  2599.             }
  2600.         }
  2601.         else
  2602.         {
  2603.             if( Machine->orientation & ORIENTATION_FLIP_X ){
  2604.                 dx=-1;
  2605.                 xoff=319;
  2606.             }
  2607.             if( Machine->orientation & ORIENTATION_FLIP_Y ){
  2608.                 yflip=1;
  2609.             }
  2610.  
  2611.             for(i=0;i<224;i++)
  2612.             {
  2613.                 if(yflip) ypos=223-i;
  2614.                 else ypos=i;
  2615.                 ver_data=READ_WORD(data_ver);
  2616.                 if((ver_data & 0x800) == priority)
  2617.                 {
  2618.  
  2619.                     if(ver_data & 0x800)
  2620.                     {
  2621.                         colors[0] = paldata1[ ver_data&0x3f ];
  2622.                         // fill line
  2623.                         line16 = (UINT16 *)bitmap->line[ypos];
  2624.                         for(j=0;j<320;j++)
  2625.                         {
  2626.                             *line16++ = colors[0];
  2627.                         }
  2628.                     }
  2629.                     else
  2630.                     {
  2631.                         // copy line
  2632.                         line16 = (UINT16 *)bitmap->line[ypos]+xoff;
  2633.                         ver_data=ver_data & 0x01ff;        //???
  2634.                         colorflip_info = READ_WORD(&gr_flip[ver_data<<1]);
  2635.  
  2636.                         colors[0] = paldata2[ ((colorflip_info >> 8) & 0x1f) + 0x20 ];        //??
  2637.  
  2638.                         colorflip = (colorflip_info >> 3) & 1;
  2639.  
  2640.                         colors[1] = paldata2[ gr_colorflip[colorflip][0] ];
  2641.                         colors[2] = paldata2[ gr_colorflip[colorflip][1] ];
  2642.                         colors[3] = paldata2[ gr_colorflip[colorflip][2] ];
  2643.  
  2644.                         hor_pos = (READ_WORD(&gr_hor[ver_data<<1]) );
  2645.                         hor_pos2= (READ_WORD(&gr_hor[(ver_data<<1)+0x400]) );
  2646.  
  2647.                         ver_data=ver_data>>1;
  2648.                         if( ver_data != 0 )
  2649.                         {
  2650.                             ver_data = (ver_data-1) << gr_bitmap_width;
  2651.                         }
  2652.  
  2653.                         source  = data + ((hor_pos +0x200) & 0x7ff) + 768 + ver_data + 8;
  2654.                         source2 = data + ((hor_pos2+0x200) & 0x7ff) + 768 + ver_data + 8;
  2655.  
  2656.                         switch(second_road)
  2657.                         {
  2658.                             case 0:    source2=source;    break;
  2659.                             case 2:    temp=source;source=source2;source2=temp; break;
  2660.                             case 3:    source=source2;    break;
  2661.                         }
  2662.  
  2663.                         source2++;
  2664.  
  2665.                         for(j=0;j<320;j++)
  2666.                         {
  2667.                             if(*source2 <= *source)
  2668.                                 *line16 = colors[*source];
  2669.                             else
  2670.                                 *line16 = colors[*source2];
  2671.                             source++;
  2672.                             source2++;
  2673.                             line16+=dx;
  2674.                         }
  2675.                     }
  2676.                 }
  2677.                 data_ver+=2;
  2678.             }
  2679.         }
  2680.     }
  2681.     else
  2682.     {
  2683.         if( Machine->orientation & ORIENTATION_SWAP_XY )
  2684.         {
  2685.             if( Machine->orientation & ORIENTATION_FLIP_Y ){
  2686.                 dx=-1;
  2687.                 xoff=319;
  2688.             }
  2689.             if( Machine->orientation & ORIENTATION_FLIP_X ){
  2690.                 yflip=1;
  2691.             }
  2692.  
  2693.             for(i=0;i<224;i++)
  2694.             {
  2695.                 if(yflip) ypos=223-i;
  2696.                 else ypos=i;
  2697.                 ver_data=READ_WORD(data_ver);
  2698.                 if((ver_data & 0x800) == priority)
  2699.                 {
  2700.  
  2701.                     if(ver_data & 0x800)
  2702.                     {
  2703.                         colors[0] = paldata1[ ver_data&0x3f ];
  2704.                         // fill line
  2705.                         for(j=0;j<320;j++)
  2706.                         {
  2707.                             bitmap->line[j][ypos]=colors[0];
  2708.                         }
  2709.                     }
  2710.                     else
  2711.                     {
  2712.                         // copy line
  2713.                         ver_data=ver_data & 0x01ff;        //???
  2714.                         colorflip_info = READ_WORD(&gr_flip[ver_data<<1]);
  2715.  
  2716.                         colors[0] = paldata2[ ((colorflip_info >> 8) & 0x1f) + 0x20 ];        //??
  2717.  
  2718.                         colorflip = (colorflip_info >> 3) & 1;
  2719.  
  2720.                         colors[1] = paldata2[ gr_colorflip[colorflip][0] ];
  2721.                         colors[2] = paldata2[ gr_colorflip[colorflip][1] ];
  2722.                         colors[3] = paldata2[ gr_colorflip[colorflip][2] ];
  2723.  
  2724.                         hor_pos = (READ_WORD(&gr_hor[ver_data<<1]) );
  2725.                         hor_pos2= (READ_WORD(&gr_hor[(ver_data<<1)+0x400]) );
  2726.  
  2727.                         ver_data=ver_data>>1;
  2728.                         if( ver_data != 0 )
  2729.                         {
  2730.                             ver_data = (ver_data-1) << gr_bitmap_width;
  2731.                         }
  2732.  
  2733.                         source  = data + ((hor_pos +0x200) & 0x7ff) + 768 + ver_data + 8;
  2734.                         source2 = data + ((hor_pos2+0x200) & 0x7ff) + 768 + ver_data + 8;
  2735.  
  2736.                         switch(second_road)
  2737.                         {
  2738.                             case 0:    source2=source;    break;
  2739.                             case 2:    temp=source;source=source2;source2=temp; break;
  2740.                             case 3:    source=source2;    break;
  2741.                         }
  2742.  
  2743.                         source2++;
  2744.  
  2745.                         for(j=0;j<320;j++)
  2746.                         {
  2747.                             if(*source2 <= *source)
  2748.                                 bitmap->line[xoff+j*dx][ypos] = colors[*source];
  2749.                             else
  2750.                                 bitmap->line[xoff+j*dx][ypos] = colors[*source2];
  2751.                             source++;
  2752.                             source2++;
  2753.                         }
  2754.                     }
  2755.                 }
  2756.                 data_ver+=2;
  2757.             }
  2758.         }
  2759.         else
  2760.         {
  2761.             if( Machine->orientation & ORIENTATION_FLIP_X ){
  2762.                 dx=-1;
  2763.                 xoff=319;
  2764.             }
  2765.             if( Machine->orientation & ORIENTATION_FLIP_Y ){
  2766.                 yflip=1;
  2767.             }
  2768.  
  2769.             for(i=0;i<224;i++)
  2770.             {
  2771.                 if(yflip) ypos=223-i;
  2772.                 else ypos=i;
  2773.                 ver_data=READ_WORD(data_ver);
  2774.                 if((ver_data & 0x800) == priority)
  2775.                 {
  2776.  
  2777.                     if(ver_data & 0x800)
  2778.                     {
  2779.                         colors[0] = paldata1[ ver_data&0x3f ];
  2780.                         // fill line
  2781.                         line32 = (UINT32 *)bitmap->line[ypos];
  2782.                         fastfill = colors[0] + (colors[0] << 8) + (colors[0] << 16) + (colors[0] << 24);
  2783.                         for(j=0;j<320;j+=4)
  2784.                         {
  2785.                             *line32++ = fastfill;
  2786.                         }
  2787.                     }
  2788.                     else
  2789.                     {
  2790.                         // copy line
  2791.                         line = bitmap->line[ypos]+xoff;
  2792.                         ver_data=ver_data & 0x01ff;        //???
  2793.                         colorflip_info = READ_WORD(&gr_flip[ver_data<<1]);
  2794.  
  2795.                         colors[0] = paldata2[ ((colorflip_info >> 8) & 0x1f) + 0x20 ];        //??
  2796.  
  2797.                         colorflip = (colorflip_info >> 3) & 1;
  2798.  
  2799.                         colors[1] = paldata2[ gr_colorflip[colorflip][0] ];
  2800.                         colors[2] = paldata2[ gr_colorflip[colorflip][1] ];
  2801.                         colors[3] = paldata2[ gr_colorflip[colorflip][2] ];
  2802.  
  2803.                         hor_pos = (READ_WORD(&gr_hor[ver_data<<1]) );
  2804.                         hor_pos2= (READ_WORD(&gr_hor[(ver_data<<1)+0x400]) );
  2805.  
  2806.                         ver_data=ver_data>>1;
  2807.                         if( ver_data != 0 )
  2808.                         {
  2809.                             ver_data = (ver_data-1) << gr_bitmap_width;
  2810.                         }
  2811.  
  2812.                         source  = data + ((hor_pos +0x200) & 0x7ff) + 768 + ver_data + 8;
  2813.                         source2 = data + ((hor_pos2+0x200) & 0x7ff) + 768 + ver_data + 8;
  2814.  
  2815.                         switch(second_road)
  2816.                         {
  2817.                             case 0:    source2=source;    break;
  2818.                             case 2:    temp=source;source=source2;source2=temp; break;
  2819.                             case 3:    source=source2;    break;
  2820.                         }
  2821.  
  2822.                         source2++;
  2823.  
  2824.                         for(j=0;j<320;j++)
  2825.                         {
  2826.                             if(*source2 <= *source)
  2827.                                 *line = colors[*source];
  2828.                             else
  2829.                                 *line = colors[*source2];
  2830.                             source++;
  2831.                             source2++;
  2832.                             line+=dx;
  2833.                         }
  2834.                     }
  2835.                 }
  2836.                 data_ver+=2;
  2837.             }
  2838.         }
  2839.     }
  2840. }
  2841.  
  2842. // Refresh for Outrun
  2843. void sys16_or_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh){
  2844.     if( sys16_update_proc ) sys16_update_proc();
  2845.     update_page();
  2846.  
  2847.     // from sys16 emu (Not sure if this is the best place for this?)
  2848.     {
  2849.         static int freeze_counter=0;
  2850.         if (!sys16_refreshenable)
  2851.         {
  2852.             freeze_counter=4;
  2853.             sys16_freezepalette=1;
  2854.         }
  2855.         if (freeze_counter)
  2856.         {
  2857.             freeze_counter--;
  2858.             return;
  2859.         }
  2860.         else if(sys16_freezepalette)
  2861.         {
  2862.             sys16_refresh_palette();
  2863.             sys16_freezepalette=0;
  2864.         }
  2865.     }
  2866.  
  2867.     if( sys16_refreshenable ){
  2868.  
  2869.         tilemap_set_scrollx( background, 0, -320-sys16_bg_scrollx+sys16_bgxoffset );
  2870.         tilemap_set_scrollx( foreground, 0, -320-sys16_fg_scrollx+sys16_fgxoffset );
  2871.  
  2872.         tilemap_set_scrolly( background, 0, -256+sys16_bg_scrolly );
  2873.         tilemap_set_scrolly( foreground, 0, -256+sys16_fg_scrolly );
  2874.  
  2875.         tilemap_update(  ALL_TILEMAPS  );
  2876.         get_sprite_info();
  2877.  
  2878.         palette_init_used_colors();
  2879.         mark_sprite_colors(); // custom; normally this would be handled by the sprite manager
  2880.         sprite_update();
  2881.         grv2_colors();
  2882.  
  2883.         if( palette_recalc() ) tilemap_mark_all_pixels_dirty( ALL_TILEMAPS );
  2884.         build_shadow_table();
  2885.         tilemap_render(  ALL_TILEMAPS  );
  2886.  
  2887.         render_grv2(bitmap,1);
  2888.  
  2889.         tilemap_draw( bitmap, background, 0 );
  2890.         tilemap_draw( bitmap, foreground, 0 );
  2891.  
  2892.         render_grv2(bitmap,0);
  2893.  
  2894.         sprite_draw(sprite_list,0);
  2895.  
  2896.         tilemap_draw( bitmap, text_layer, 0 );
  2897.  
  2898.     }
  2899.  
  2900. #ifdef SYS16_DEBUG
  2901.     dump_tilemap();
  2902. #endif
  2903. }
  2904.  
  2905.  
  2906. // hideous kludge to display quartet title screen correctly
  2907. static void draw_quartet_title_screen( struct osd_bitmap *bitmap,int playfield )
  2908. {
  2909.     unsigned char *xscroll,*yscroll;
  2910.     int r,c,scroll;
  2911.     struct tilemap *tilemap;
  2912.     struct rectangle clip;
  2913.  
  2914.     int top,bottom,left,right;
  2915.  
  2916.  
  2917.     if(playfield==0) // background
  2918.     {
  2919.         xscroll=&sys16_textram[0x0fc0];
  2920.         yscroll=&sys16_textram[0x0f58];
  2921.         tilemap=background;
  2922.     }
  2923.     else
  2924.     {
  2925.         xscroll=&sys16_textram[0x0f80];
  2926.         yscroll=&sys16_textram[0x0f30];
  2927.         tilemap=foreground;
  2928.     }
  2929.  
  2930.     left = tilemap->clip_left;
  2931.     right = tilemap->clip_right;
  2932.     top = tilemap->clip_top;
  2933.     bottom = tilemap->clip_bottom;
  2934.  
  2935.     for(r=0;r<14;r++)
  2936.     {
  2937.         clip.min_y=r*16;
  2938.         clip.max_y=r*16+15;
  2939.         for(c=0;c<10;c++)
  2940.         {
  2941.             clip.min_x=c*32;
  2942.             clip.max_x=c*32+31;
  2943.             tilemap_set_clip( tilemap, &clip );
  2944.             scroll = READ_WORD(&xscroll[r*4])&0x3ff;
  2945.             tilemap_set_scrollx( tilemap, 0, (-320-scroll+sys16_bgxoffset)&0x3ff );
  2946.             scroll = READ_WORD(&yscroll[c*4])&0x1ff;
  2947.             tilemap_set_scrolly( tilemap, 0, (-256+scroll)&0x1ff );
  2948.             tilemap_draw( bitmap, tilemap, 0 );
  2949.         }
  2950.     }
  2951. /*
  2952.     for(r=0;r<28;r++)
  2953.     {
  2954.         clip.min_y=r*8;
  2955.         clip.max_y=r*8+7;
  2956.         for(c=0;c<20;c++)
  2957.         {
  2958.             clip.min_x=c*16;
  2959.             clip.max_x=c*16+15;
  2960.             tilemap_set_clip( tilemap, &clip );
  2961.             scroll = READ_WORD(&xscroll[r*2])&0x3ff;
  2962.             tilemap_set_scrollx( tilemap, 0, (-320-scroll+sys16_bgxoffset)&0x3ff );
  2963.             scroll = READ_WORD(&yscroll[c*2])&0x1ff;
  2964.             tilemap_set_scrolly( tilemap, 0, (-256+scroll)&0x1ff );
  2965.             tilemap_draw( bitmap, tilemap, 0 );
  2966.         }
  2967.     }
  2968. */
  2969.     tilemap->clip_left = left;
  2970.     tilemap->clip_right = right;
  2971.     tilemap->clip_top = top;
  2972.     tilemap->clip_bottom = bottom;
  2973. }
  2974.  
  2975.  
  2976. #ifdef SYS16_DEBUG
  2977. void dump_tilemap(void)
  2978. {
  2979.     const UINT16 *source;
  2980.     int row,col,r,c;
  2981.     int data;
  2982.  
  2983.     if(!keyboard_pressed_memory(KEYCODE_Y)) return;
  2984.  
  2985.     logerror("Back %2x %2x %2x %2x\n",sys16_bg_page[0],sys16_bg_page[1],sys16_bg_page[2],sys16_bg_page[3]);
  2986.     for(r=0;r<64;r++)
  2987.     {
  2988.         for(c=0;c<128;c++)
  2989.         {
  2990.             source = (const UINT16 *)sys16_tileram;
  2991.             row=r;col=c;
  2992.             if( row<32 ){
  2993.                 if( col<64 ){
  2994.                     source += 64*32*sys16_bg_page[0];
  2995.                 }
  2996.                 else {
  2997.                     source += 64*32*sys16_bg_page[1];
  2998.                 }
  2999.             }
  3000.             else {
  3001.                 if( col<64 ){
  3002.                     source += 64*32*sys16_bg_page[2];
  3003.                 }
  3004.                 else {
  3005.                     source += 64*32*sys16_bg_page[3];
  3006.                 }
  3007.             }
  3008.             row = row%32;
  3009.             col = col%64;
  3010.  
  3011.             data = source[row*64+col];
  3012.             logerror("%4x ",data);
  3013.         }
  3014.         logerror("\n");
  3015.     }
  3016.  
  3017.     logerror("Front %2x %2x %2x %2x\n",sys16_fg_page[0],sys16_fg_page[1],sys16_fg_page[2],sys16_fg_page[3]);
  3018.     for(r=0;r<64;r++)
  3019.     {
  3020.         for(c=0;c<128;c++)
  3021.         {
  3022.             source = (const UINT16 *)sys16_tileram;
  3023.             row=r;col=c;
  3024.             if( row<32 ){
  3025.                 if( col<64 ){
  3026.                     source += 64*32*sys16_fg_page[0];
  3027.                 }
  3028.                 else {
  3029.                     source += 64*32*sys16_fg_page[1];
  3030.                 }
  3031.             }
  3032.             else {
  3033.                 if( col<64 ){
  3034.                     source += 64*32*sys16_fg_page[2];
  3035.                 }
  3036.                 else {
  3037.                     source += 64*32*sys16_fg_page[3];
  3038.                 }
  3039.             }
  3040.             row = row%32;
  3041.             col = col%64;
  3042.  
  3043.             data = source[row*64+col];
  3044.             logerror("%4x ",data);
  3045.         }
  3046.         logerror("\n");
  3047.     }
  3048.  
  3049.     logerror("Text\n");
  3050.     for(r=0;r<28;r++)
  3051.     {
  3052.         for(c=0;c<64;c++)
  3053.         {
  3054.             source = (const UINT16 *)sys16_textram;
  3055.             data = source[r*64+c];
  3056.             logerror("%4x ",data);
  3057.         }
  3058.         logerror("\n");
  3059.     }
  3060. }
  3061. #endif
  3062.  
  3063.